ballerina-core 1.0.256 → 1.0.257

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

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

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

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

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

@@ -1,5 +1,7 @@
 import { Unit } from "../../../main";
 import { Coroutine } from "../../coroutines/state";
 import { ValueInfiniteStreamState } from "../state";
-export declare const ValueInfiniteStreamLoader: (maxRetries?: number) => Coroutine<ValueInfiniteStreamState, ValueInfiniteStreamState, Unit>;
-//# sourceMappingURL=infiniteLoader.d.ts.map
+export declare const ValueInfiniteStreamLoader: (
+  maxRetries?: number,
+) => Coroutine<ValueInfiniteStreamState, ValueInfiniteStreamState, Unit>;
+//# sourceMappingURL=infiniteLoader.d.ts.map

package/bin/src/value-infinite-data-stream/coroutines/infiniteLoader.js

@@ -1,27 +1,62 @@
 import { AsyncState } from "../../async/state";
 import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
-import { ValueInfiniteStreamState, ValueStreamPosition, } from "../state";
+import { ValueInfiniteStreamState, ValueStreamPosition } from "../state";
 import { ValueStreamCo } from "./builder";
 export const ValueInfiniteStreamLoader = (maxRetries = 3) => {
-    const Co = ValueStreamCo();
-    const updaters = ValueInfiniteStreamState.Updaters;
-    const attemptLoad = (retryCount = 0) => Co.GetState().then((current) => current.loadingMore.kind === "loaded"
+  const Co = ValueStreamCo();
+  const updaters = ValueInfiniteStreamState.Updaters;
+  const attemptLoad = (retryCount = 0) =>
+    Co.GetState().then((current) =>
+      current.loadingMore.kind === "loaded"
         ? Co.Return(true)
-        : Co.Await(() => current.getChunk([current.position]), () => "error").then((apiResult) => {
+        : Co.Await(
+            () => current.getChunk([current.position]),
+            () => "error",
+          ).then((apiResult) => {
             return apiResult.kind == "l"
-                ? Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.loaded({})))
-                    .then(updaters.Coroutine.addLoadedChunk(current.position.chunkIndex, apiResult.value).then(updaters.Core.position(ValueStreamPosition.Updaters.Core.shouldLoad(replaceWith(false)))))
-                    .then(updaters.Core.position(ValueStreamPosition.Updaters.Core.nextStart(replaceWith(apiResult.value.to)))))
-                : retryCount < maxRetries
-                    ? Co.Wait(500).then(() => attemptLoad(retryCount + 1))
-                    : Co.Return(false);
-        }));
-    return Co.Seq([
-        Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.loading()))),
-        attemptLoad(),
-        Co.GetState().then((current) => current.loadingMore.kind !== "loaded"
-            ? Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.error("max retries reached"))))
-            : Co.Wait(0)),
-    ]);
+              ? Co.SetState(
+                  updaters.Core.loadingMore(
+                    replaceWith(AsyncState.Default.loaded({})),
+                  )
+                    .then(
+                      updaters.Coroutine.addLoadedChunk(
+                        current.position.chunkIndex,
+                        apiResult.value,
+                      ).then(
+                        updaters.Core.position(
+                          ValueStreamPosition.Updaters.Core.shouldLoad(
+                            replaceWith(false),
+                          ),
+                        ),
+                      ),
+                    )
+                    .then(
+                      updaters.Core.position(
+                        ValueStreamPosition.Updaters.Core.nextStart(
+                          replaceWith(apiResult.value.to),
+                        ),
+                      ),
+                    ),
+                )
+              : retryCount < maxRetries
+                ? Co.Wait(500).then(() => attemptLoad(retryCount + 1))
+                : Co.Return(false);
+          }),
+    );
+  return Co.Seq([
+    Co.SetState(
+      updaters.Core.loadingMore(replaceWith(AsyncState.Default.loading())),
+    ),
+    attemptLoad(),
+    Co.GetState().then((current) =>
+      current.loadingMore.kind !== "loaded"
+        ? Co.SetState(
+            updaters.Core.loadingMore(
+              replaceWith(AsyncState.Default.error("max retries reached")),
+            ),
+          )
+        : Co.Wait(0),
+    ),
+  ]);
 };
-//# sourceMappingURL=infiniteLoader.js.map
+//# sourceMappingURL=infiniteLoader.js.map

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

@@ -1,3 +1,9 @@
 import { ValueInfiniteStreamState } from "../state";
-export declare const ValueStreamDataLoader: <foreignMutations>() => import("../../template/state").Template<ValueInfiniteStreamState, ValueInfiniteStreamState, foreignMutations>;
-//# sourceMappingURL=runner.d.ts.map
+export declare const ValueStreamDataLoader: <
+  foreignMutations,
+>() => import("../../template/state").Template<
+  ValueInfiniteStreamState,
+  ValueInfiniteStreamState,
+  foreignMutations
+>;
+//# sourceMappingURL=runner.d.ts.map

package/bin/src/value-infinite-data-stream/coroutines/runner.js

@@ -1,7 +1,9 @@
 import { ValueInfiniteStreamState } from "../state";
 import { ValueStreamCo } from "./builder";
 import { ValueInfiniteStreamLoader } from "./infiniteLoader";
-export const ValueStreamDataLoader = () => ValueStreamCo().Template(ValueInfiniteStreamLoader(), {
-    runFilter: (props) => ValueInfiniteStreamState.Operations.shouldCoroutineRun(props.context),
-});
-//# sourceMappingURL=runner.js.map
+export const ValueStreamDataLoader = () =>
+  ValueStreamCo().Template(ValueInfiniteStreamLoader(), {
+    runFilter: (props) =>
+      ValueInfiniteStreamState.Operations.shouldCoroutineRun(props.context),
+  });
+//# sourceMappingURL=runner.js.map

package/bin/src/value-infinite-data-stream/state.d.ts

@@ -6,96 +6,162 @@ import { BasicFun } from "../fun/state";
 import { Guid, PredicateValue, ValueOrErrors, ValueRecord } from "../../main";
 export type ValueStreamingStatus = "reload" | "loadMore" | false;
 export type ValueStreamPosition = {
-    nextStart: number;
-    chunkSize: number;
-    chunkIndex: ValueChunkIndex;
-    shouldLoad: ValueStreamingStatus;
-    lastModifiedTime: number;
+  nextStart: number;
+  chunkSize: number;
+  chunkIndex: ValueChunkIndex;
+  shouldLoad: ValueStreamingStatus;
+  lastModifiedTime: number;
 };
 export declare const ValueStreamPosition: {
-    Default: (initialChunkSize: number, shouldLoad?: ValueStreamingStatus) => ValueStreamPosition;
-    Updaters: {
-        Template: {
-            changeChunkSize: (chunkSize: number) => Updater<ValueStreamPosition>;
-            reload: () => Updater<ValueStreamPosition>;
-            loadMore: () => Updater<ValueStreamPosition>;
-            initLoad: () => Updater<ValueStreamPosition>;
-        };
-        Core: {
-            nextStart: import("../../main").Widening<ValueStreamPosition, "nextStart">;
-            chunkSize: import("../../main").Widening<ValueStreamPosition, "chunkSize">;
-            chunkIndex: import("../../main").Widening<ValueStreamPosition, "chunkIndex">;
-            shouldLoad: import("../../main").Widening<ValueStreamPosition, "shouldLoad">;
-            lastModifiedTime: import("../../main").Widening<ValueStreamPosition, "lastModifiedTime">;
-        };
-        Coroutine: {};
+  Default: (
+    initialChunkSize: number,
+    shouldLoad?: ValueStreamingStatus,
+  ) => ValueStreamPosition;
+  Updaters: {
+    Template: {
+      changeChunkSize: (chunkSize: number) => Updater<ValueStreamPosition>;
+      reload: () => Updater<ValueStreamPosition>;
+      loadMore: () => Updater<ValueStreamPosition>;
+      initLoad: () => Updater<ValueStreamPosition>;
     };
+    Core: {
+      nextStart: import("../../main").Widening<
+        ValueStreamPosition,
+        "nextStart"
+      >;
+      chunkSize: import("../../main").Widening<
+        ValueStreamPosition,
+        "chunkSize"
+      >;
+      chunkIndex: import("../../main").Widening<
+        ValueStreamPosition,
+        "chunkIndex"
+      >;
+      shouldLoad: import("../../main").Widening<
+        ValueStreamPosition,
+        "shouldLoad"
+      >;
+      lastModifiedTime: import("../../main").Widening<
+        ValueStreamPosition,
+        "lastModifiedTime"
+      >;
+    };
+    Coroutine: {};
+  };
 };
 export type ValueChunk = {
-    hasMoreValues: boolean;
-    data: OrderedMap<Guid, ValueRecord>;
-    from: number;
-    to: number;
+  hasMoreValues: boolean;
+  data: OrderedMap<Guid, ValueRecord>;
+  from: number;
+  to: number;
 };
 export declare const ValueChunk: {
-    Default: (hasMoreValues: boolean, data: OrderedMap<Guid, ValueRecord>, from: number, to: number) => ValueChunk;
-    Updaters: {
-        Core: {
-            to: import("../../main").Widening<ValueChunk, "to">;
-            from: import("../../main").Widening<ValueChunk, "from">;
-            data: import("../../main").Widening<ValueChunk, "data">;
-            hasMoreValues: import("../../main").Widening<ValueChunk, "hasMoreValues">;
-        };
-        Template: {
-            updateValue: (valueId: Guid, valueUpdater: BasicUpdater<ValueRecord>) => Updater<ValueChunk>;
-            updateValueItem: (valueId: Guid, itemId: Guid, valueUpdater: BasicUpdater<PredicateValue>) => Updater<ValueChunk>;
-        };
+  Default: (
+    hasMoreValues: boolean,
+    data: OrderedMap<Guid, ValueRecord>,
+    from: number,
+    to: number,
+  ) => ValueChunk;
+  Updaters: {
+    Core: {
+      to: import("../../main").Widening<ValueChunk, "to">;
+      from: import("../../main").Widening<ValueChunk, "from">;
+      data: import("../../main").Widening<ValueChunk, "data">;
+      hasMoreValues: import("../../main").Widening<ValueChunk, "hasMoreValues">;
+    };
+    Template: {
+      updateValue: (
+        valueId: Guid,
+        valueUpdater: BasicUpdater<ValueRecord>,
+      ) => Updater<ValueChunk>;
+      updateValueItem: (
+        valueId: Guid,
+        itemId: Guid,
+        valueUpdater: BasicUpdater<PredicateValue>,
+      ) => Updater<ValueChunk>;
     };
+  };
 };
 export type ValueChunkIndex = number;
 export type StateChunkIndex = number;
 export type StateChunkValue = Map<string, unknown>;
 export declare const StateChunkItem: {
-    Default: (state: Record<string, unknown>) => StateChunkValue;
+  Default: (state: Record<string, unknown>) => StateChunkValue;
 };
 export type StateChunk = Map<string, StateChunkValue>;
 export declare const StateChunk: {
-    Default: (state: Record<string, StateChunkValue>) => StateChunk;
+  Default: (state: Record<string, StateChunkValue>) => StateChunk;
 };
 export type ValueInfiniteStreamState = {
-    loadingMore: AsyncState<Unit>;
-    loadedElements: OrderedMap<ValueChunkIndex, ValueChunk>;
-    position: ValueStreamPosition;
-    getChunk: BasicFun<[ValueStreamPosition], Promise<ValueChunk>>;
+  loadingMore: AsyncState<Unit>;
+  loadedElements: OrderedMap<ValueChunkIndex, ValueChunk>;
+  position: ValueStreamPosition;
+  getChunk: BasicFun<[ValueStreamPosition], Promise<ValueChunk>>;
 };
 export declare const ValueInfiniteStreamState: {
-    Default: (initialChunkSize: number, getChunk: ValueInfiniteStreamState["getChunk"], shouldLoad?: ValueStreamingStatus) => ValueInfiniteStreamState;
-    Operations: {
-        shouldCoroutineRun: (current: ValueInfiniteStreamState) => boolean;
-        loadNextPage: (current: ValueInfiniteStreamState) => boolean;
-        getChunkIndexForValue: (current: ValueInfiniteStreamState, valueId: Guid) => ValueOrErrors<number, string>;
+  Default: (
+    initialChunkSize: number,
+    getChunk: ValueInfiniteStreamState["getChunk"],
+    shouldLoad?: ValueStreamingStatus,
+  ) => ValueInfiniteStreamState;
+  Operations: {
+    shouldCoroutineRun: (current: ValueInfiniteStreamState) => boolean;
+    loadNextPage: (current: ValueInfiniteStreamState) => boolean;
+    getChunkIndexForValue: (
+      current: ValueInfiniteStreamState,
+      valueId: Guid,
+    ) => ValueOrErrors<number, string>;
+  };
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (
+        chunkIndex: number,
+        newChunk: ValueChunk,
+      ) => Updater<ValueInfiniteStreamState>;
+    };
+    Core: {
+      whenNotAlreadyLoading: (
+        _: BasicUpdater<ValueInfiniteStreamState>,
+      ) => Updater<ValueInfiniteStreamState>;
+      position: (
+        positionUpdater: Updater<ValueInfiniteStreamState["position"]>,
+      ) => Updater<ValueInfiniteStreamState>;
+      clearLoadedElements: () => Updater<ValueInfiniteStreamState>;
+      loadedElements: import("../../main").Widening<
+        ValueInfiniteStreamState,
+        "loadedElements"
+      >;
+      loadingMore: import("../../main").Widening<
+        ValueInfiniteStreamState,
+        "loadingMore"
+      >;
+      getChunk: import("../../main").Widening<
+        ValueInfiniteStreamState,
+        "getChunk"
+      >;
     };
-    Updaters: {
-        Coroutine: {
-            addLoadedChunk: (chunkIndex: number, newChunk: ValueChunk) => Updater<ValueInfiniteStreamState>;
-        };
-        Core: {
-            whenNotAlreadyLoading: (_: BasicUpdater<ValueInfiniteStreamState>) => Updater<ValueInfiniteStreamState>;
-            position: (positionUpdater: Updater<ValueInfiniteStreamState["position"]>) => Updater<ValueInfiniteStreamState>;
-            clearLoadedElements: () => Updater<ValueInfiniteStreamState>;
-            loadedElements: import("../../main").Widening<ValueInfiniteStreamState, "loadedElements">;
-            loadingMore: import("../../main").Widening<ValueInfiniteStreamState, "loadingMore">;
-            getChunk: import("../../main").Widening<ValueInfiniteStreamState, "getChunk">;
-        };
-        Template: {
-            reload: (getChunk: ValueInfiniteStreamState["getChunk"]) => Updater<ValueInfiniteStreamState>;
-            loadMore: () => Updater<ValueInfiniteStreamState>;
-            initLoad: () => Updater<ValueInfiniteStreamState>;
-            updateChunkValue: (chunkIndex: number, chunkValueKey: Guid) => (valueUpdater: BasicUpdater<ValueRecord>) => Updater<ValueInfiniteStreamState>;
-            updateChunkValueItem: (chunkIndex: number, chunkValueKey: Guid, chunkValueItemKey: Guid) => (valueUpdater: BasicUpdater<PredicateValue>) => Updater<ValueInfiniteStreamState>;
-        };
+    Template: {
+      reload: (
+        getChunk: ValueInfiniteStreamState["getChunk"],
+      ) => Updater<ValueInfiniteStreamState>;
+      loadMore: () => Updater<ValueInfiniteStreamState>;
+      initLoad: () => Updater<ValueInfiniteStreamState>;
+      updateChunkValue: (
+        chunkIndex: number,
+        chunkValueKey: Guid,
+      ) => (
+        valueUpdater: BasicUpdater<ValueRecord>,
+      ) => Updater<ValueInfiniteStreamState>;
+      updateChunkValueItem: (
+        chunkIndex: number,
+        chunkValueKey: Guid,
+        chunkValueItemKey: Guid,
+      ) => (
+        valueUpdater: BasicUpdater<PredicateValue>,
+      ) => Updater<ValueInfiniteStreamState>;
     };
+  };
 };
 export type ValueInfiniteStreamReadonlyContext = Unit;
 export type ValueInfiniteStreamWritableState = ValueInfiniteStreamState;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map