ballerina-core 1.0.220 → 1.0.222

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

@@ -6,89 +6,204 @@ import { BasicFun } from "../fun/state";
 import { Guid, SimpleCallback } from "../../main";
 export type DeltaT = number;
 export type Coroutine<context, state, result> = {
-    ([context, deltaT]: [context, DeltaT]): CoroutineStep<context, state, result>;
-    embed: <parentContext, parentState>(narrow: BasicFun<parentContext, context | undefined>, widen: BasicFun<BasicUpdater<state>, BasicUpdater<parentState>>) => Coroutine<parentContext, parentState, result>;
-    then: <nextResult>(f: BasicFun<result, Coroutine<context, state, nextResult>>) => Coroutine<context, state, nextResult>;
-    seq: <nextResult>(k: Coroutine<context, state, nextResult>) => Coroutine<context, state, nextResult>;
+  ([context, deltaT]: [context, DeltaT]): CoroutineStep<context, state, result>;
+  embed: <parentContext, parentState>(
+    narrow: BasicFun<parentContext, context | undefined>,
+    widen: BasicFun<BasicUpdater<state>, BasicUpdater<parentState>>,
+  ) => Coroutine<parentContext, parentState, result>;
+  then: <nextResult>(
+    f: BasicFun<result, Coroutine<context, state, nextResult>>,
+  ) => Coroutine<context, state, nextResult>;
+  seq: <nextResult>(
+    k: Coroutine<context, state, nextResult>,
+  ) => Coroutine<context, state, nextResult>;
 };
 export declare const Coroutine: {
-    Create: <context, state, result>(p: BasicFun<[context, DeltaT], CoroutineStep<context, state, result>>) => Coroutine<context, state, result>;
-    UpdateState: <context, state>(stateUpdater: BasicFun<state, BasicUpdater<state>>) => Coroutine<context, state, Unit>;
-    SetState: <context, state>(stateUpdater: BasicUpdater<state>) => Coroutine<context, state, Unit>;
-    GetState: <context, state>() => Coroutine<context, state, context>;
-    Start: <context, state>() => Coroutine<context, state, Unit>;
-    Return: <context, state, result>(result: result) => Coroutine<context, state, result>;
-    Yield: <context, state, result>(next: Coroutine<context, state, result>) => Coroutine<context, state, result>;
-    Waiting: <context, state, result>(msLeft: number, next: Coroutine<context, state, result>) => Coroutine<context, state, result>;
-    MapContext: <childContext, result, parentContext, state>(p: Coroutine<childContext, state, result>, narrow: BasicFun<parentContext, childContext | undefined>) => Coroutine<parentContext, state, result>;
-    Embed: <childContext, childState, result, parentContext, parentState>(p: Coroutine<childContext, childState, result>, narrow: BasicFun<parentContext, childContext | undefined>, widen: BasicFun<BasicUpdater<childState>, BasicUpdater<parentState>>) => Coroutine<parentContext, parentState, result>;
-    MapState: <context, state, newState, result>(p: Coroutine<context, state, result>, f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>) => Coroutine<context, newState, result>;
-    Tick: <context, state, result>(context: context, p: Coroutine<context, state, result>, deltaT: number) => {
+  Create: <context, state, result>(
+    p: BasicFun<[context, DeltaT], CoroutineStep<context, state, result>>,
+  ) => Coroutine<context, state, result>;
+  UpdateState: <context, state>(
+    stateUpdater: BasicFun<state, BasicUpdater<state>>,
+  ) => Coroutine<context, state, Unit>;
+  SetState: <context, state>(
+    stateUpdater: BasicUpdater<state>,
+  ) => Coroutine<context, state, Unit>;
+  GetState: <context, state>() => Coroutine<context, state, context>;
+  Start: <context, state>() => Coroutine<context, state, Unit>;
+  Return: <context, state, result>(
+    result: result,
+  ) => Coroutine<context, state, result>;
+  Yield: <context, state, result>(
+    next: Coroutine<context, state, result>,
+  ) => Coroutine<context, state, result>;
+  Waiting: <context, state, result>(
+    msLeft: number,
+    next: Coroutine<context, state, result>,
+  ) => Coroutine<context, state, result>;
+  MapContext: <childContext, result, parentContext, state>(
+    p: Coroutine<childContext, state, result>,
+    narrow: BasicFun<parentContext, childContext | undefined>,
+  ) => Coroutine<parentContext, state, result>;
+  Embed: <childContext, childState, result, parentContext, parentState>(
+    p: Coroutine<childContext, childState, result>,
+    narrow: BasicFun<parentContext, childContext | undefined>,
+    widen: BasicFun<BasicUpdater<childState>, BasicUpdater<parentState>>,
+  ) => Coroutine<parentContext, parentState, result>;
+  MapState: <context, state, newState, result>(
+    p: Coroutine<context, state, result>,
+    f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>,
+  ) => Coroutine<context, newState, result>;
+  Tick: <context, state, result>(
+    context: context,
+    p: Coroutine<context, state, result>,
+    deltaT: number,
+  ) =>
+    | {
         kind: "continuing";
         excludeOthers?: true;
         state: BasicUpdater<state> | undefined;
         next: Coroutine<context, state, result>;
-    } | {
+      }
+    | {
         kind: "done";
         state: BasicUpdater<state> | undefined;
         result: result;
-    };
-    Nothing: <context, state, result>() => Coroutine<context, state, result>;
-    Any: <context, state, result>(ps: Array<Coroutine<context, state, result>>) => Coroutine<context, state, result>;
-    All: <context, state, result>(ps: Array<Coroutine<context, state, result>>) => Coroutine<context, state, Array<result>>;
-    Repeat: <context, state>(p: Coroutine<context, state, Unit>) => Coroutine<context, state, Unit>;
-    Seq: <context, state>(ps: Array<Coroutine<context, state, Unit>>) => Coroutine<context, state, Unit>;
-    For: <context, state, element>(collection: Collection<number, element>, p: BasicFun<element, Coroutine<context, state, Unit>>) => Coroutine<context, state, Unit>;
-    While: <context, state>(predicate: BasicFun<[context], boolean>, p: Coroutine<context, state, Unit>) => Coroutine<context, state, Unit>;
-    Wait: <context, state>(ms: number) => Coroutine<context, state, Unit>;
-    Await: <context, state, result, error>(promise: BasicFun<Unit, Promise<result>>, onCatch: BasicFun<any, error>, debugName?: string) => Coroutine<context, state, Sum<result, error>>;
-    On: <eventKind, event, context extends {
-        inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
-    }, state extends {
-        inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
-    }, matchedEvent extends InboundKindFromContext<context>>(kind: matchedEvent, filter?: BasicFun<[InboundEventFromContext<context & state> & {
-        kind: matchedEvent;
-    }, context & state], boolean>) => Coroutine<context & state, state, InboundEventFromContext<context & state> & {
-        kind: matchedEvent;
-    }>;
-    Trigger: <context, state extends {
-        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
-    }, event extends {
-        id: Guid;
-        kind: kind;
-    }, kind extends string>(event: event) => Coroutine<context & state, state, Unit>;
-    Do: <context, state>(action: SimpleCallback<void>) => Coroutine<context, state, Unit>;
+      };
+  Nothing: <context, state, result>() => Coroutine<context, state, result>;
+  Any: <context, state, result>(
+    ps: Array<Coroutine<context, state, result>>,
+  ) => Coroutine<context, state, result>;
+  All: <context, state, result>(
+    ps: Array<Coroutine<context, state, result>>,
+  ) => Coroutine<context, state, Array<result>>;
+  Repeat: <context, state>(
+    p: Coroutine<context, state, Unit>,
+  ) => Coroutine<context, state, Unit>;
+  Seq: <context, state>(
+    ps: Array<Coroutine<context, state, Unit>>,
+  ) => Coroutine<context, state, Unit>;
+  For: <context, state, element>(
+    collection: Collection<number, element>,
+    p: BasicFun<element, Coroutine<context, state, Unit>>,
+  ) => Coroutine<context, state, Unit>;
+  While: <context, state>(
+    predicate: BasicFun<[context], boolean>,
+    p: Coroutine<context, state, Unit>,
+  ) => Coroutine<context, state, Unit>;
+  Wait: <context, state>(ms: number) => Coroutine<context, state, Unit>;
+  Await: <context, state, result, error>(
+    promise: BasicFun<Unit, Promise<result>>,
+    onCatch: BasicFun<any, error>,
+    debugName?: string,
+  ) => Coroutine<context, state, Sum<result, error>>;
+  On: <
+    eventKind,
+    event,
+    context extends {
+      inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
+    },
+    state extends {
+      inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
+    },
+    matchedEvent extends InboundKindFromContext<context>,
+  >(
+    kind: matchedEvent,
+    filter?: BasicFun<
+      [
+        InboundEventFromContext<context & state> & {
+          kind: matchedEvent;
+        },
+        context & state,
+      ],
+      boolean
+    >,
+  ) => Coroutine<
+    context & state,
+    state,
+    InboundEventFromContext<context & state> & {
+      kind: matchedEvent;
+    }
+  >;
+  Trigger: <
+    context,
+    state extends {
+      outboundEvents: Map<kind, OrderedMap<Guid, event>>;
+    },
+    event extends {
+      id: Guid;
+      kind: kind;
+    },
+    kind extends string,
+  >(
+    event: event,
+  ) => Coroutine<context & state, state, Unit>;
+  Do: <context, state>(
+    action: SimpleCallback<void>,
+  ) => Coroutine<context, state, Unit>;
 };
 export type CoroutineStep<context, state, result> = {
-    newState: BasicUpdater<state> | undefined;
-} & ({
-    kind: "result";
-    result: result;
-} | {
-    kind: "then";
-    p: Coroutine<context, state, any>;
-    k: BasicFun<any, Coroutine<context, state, result>>;
-} | {
-    kind: "yield";
-    next: Coroutine<context, state, result>;
-} | {
-    kind: "waiting";
-    msLeft: number;
-    next: Coroutine<context, state, result>;
-}) & {};
+  newState: BasicUpdater<state> | undefined;
+} & (
+  | {
+      kind: "result";
+      result: result;
+    }
+  | {
+      kind: "then";
+      p: Coroutine<context, state, any>;
+      k: BasicFun<any, Coroutine<context, state, result>>;
+    }
+  | {
+      kind: "yield";
+      next: Coroutine<context, state, result>;
+    }
+  | {
+      kind: "waiting";
+      msLeft: number;
+      next: Coroutine<context, state, result>;
+    }
+) & {};
 export declare const CoroutineStep: {
-    Result: <context, state, result>(newState: BasicUpdater<state> | undefined, result: result) => CoroutineStep<context, state, result>;
-    Then: <context, state, result>(newState: BasicUpdater<state> | undefined, p: Coroutine<context, state, any>, k: BasicFun<any, Coroutine<context, state, result>>) => CoroutineStep<context, state, result>;
-    Yield: <context, state, result>(newState: BasicUpdater<state> | undefined, next: Coroutine<context, state, result>) => CoroutineStep<context, state, result>;
-    Waiting: <context, state, result>(newState: BasicUpdater<state> | undefined, msLeft: number, next: Coroutine<context, state, result>) => CoroutineStep<context, state, result>;
-    MapContext: <childContext, parentContext, state, result>(p: CoroutineStep<childContext, state, result>, narrow: BasicFun<parentContext, childContext | undefined>) => CoroutineStep<parentContext, state, result>;
-    MapState: <context, state, newState, result>(p: CoroutineStep<context, state, result>, f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>) => CoroutineStep<context, newState, result>;
-    Embed: <childContext, childState, result, parentContext, parentState>(p: CoroutineStep<childContext, childState, result>, narrow: BasicFun<parentContext, childContext | undefined>, widen: BasicFun<BasicUpdater<childState>, BasicUpdater<parentState>>) => CoroutineStep<parentContext, parentState, result>;
+  Result: <context, state, result>(
+    newState: BasicUpdater<state> | undefined,
+    result: result,
+  ) => CoroutineStep<context, state, result>;
+  Then: <context, state, result>(
+    newState: BasicUpdater<state> | undefined,
+    p: Coroutine<context, state, any>,
+    k: BasicFun<any, Coroutine<context, state, result>>,
+  ) => CoroutineStep<context, state, result>;
+  Yield: <context, state, result>(
+    newState: BasicUpdater<state> | undefined,
+    next: Coroutine<context, state, result>,
+  ) => CoroutineStep<context, state, result>;
+  Waiting: <context, state, result>(
+    newState: BasicUpdater<state> | undefined,
+    msLeft: number,
+    next: Coroutine<context, state, result>,
+  ) => CoroutineStep<context, state, result>;
+  MapContext: <childContext, parentContext, state, result>(
+    p: CoroutineStep<childContext, state, result>,
+    narrow: BasicFun<parentContext, childContext | undefined>,
+  ) => CoroutineStep<parentContext, state, result>;
+  MapState: <context, state, newState, result>(
+    p: CoroutineStep<context, state, result>,
+    f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>,
+  ) => CoroutineStep<context, newState, result>;
+  Embed: <childContext, childState, result, parentContext, parentState>(
+    p: CoroutineStep<childContext, childState, result>,
+    narrow: BasicFun<parentContext, childContext | undefined>,
+    widen: BasicFun<BasicUpdater<childState>, BasicUpdater<parentState>>,
+  ) => CoroutineStep<parentContext, parentState, result>;
 };
 export type InboundEventFromContext<s> = s extends {
-    inboundEvents: Map<infer _kind, OrderedMap<Guid, infer event>>;
-} ? event : never;
+  inboundEvents: Map<infer _kind, OrderedMap<Guid, infer event>>;
+}
+  ? event
+  : never;
 export type InboundKindFromContext<s> = s extends {
-    inboundEvents: Map<infer kind, OrderedMap<Guid, infer _event>>;
-} ? kind : never;
-//# sourceMappingURL=state.d.ts.map
+  inboundEvents: Map<infer kind, OrderedMap<Guid, infer _event>>;
+}
+  ? kind
+  : never;
+//# sourceMappingURL=state.d.ts.map

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

@@ -3,15 +3,24 @@ import { BasicFun } from "../fun/state";
 import { Coroutine } from "./state";
 import { Template, TemplateProps } from "../template/state";
 export type CoroutineComponentOptions<context, state> = {
-    interval?: number;
-    key?: BasicFun<TemplateProps<context & state, state, Unit>, string>;
-    restartWhenFinished?: boolean;
-    runFilter?: BasicFun<TemplateProps<context & state, state, Unit>, boolean>;
+  interval?: number;
+  key?: BasicFun<TemplateProps<context & state, state, Unit>, string>;
+  restartWhenFinished?: boolean;
+  runFilter?: BasicFun<TemplateProps<context & state, state, Unit>, boolean>;
 };
 type CoroutineReadonlyContext<context, state> = {
-    initialCoroutine: Coroutine<context, state, Unit>;
-    options?: CoroutineComponentOptions<context, state>;
+  initialCoroutine: Coroutine<context, state, Unit>;
+  options?: CoroutineComponentOptions<context, state>;
 };
-export declare const CoroutineTemplate: <context, state, foreignMutations>() => Template<context & CoroutineReadonlyContext<context, state> & state, state, foreignMutations, Unit>;
+export declare const CoroutineTemplate: <
+  context,
+  state,
+  foreignMutations,
+>() => Template<
+  context & CoroutineReadonlyContext<context, state> & state,
+  state,
+  foreignMutations,
+  Unit
+>;
 export {};
-//# sourceMappingURL=template.d.ts.map
+//# sourceMappingURL=template.d.ts.map

package/bin/src/debounced/coroutines/debounce.d.ts

@@ -2,9 +2,18 @@ import { ApiResultStatus } from "../../apiResultStatus/state";
 import { Coroutine } from "../../coroutines/state";
 import { Unit } from "../../fun/domains/unit/state";
 import { Debounced, DebouncedStatus, DirtyStatus } from "../state";
-export declare const Debounce: <value, context = Unit>(k: Coroutine<value & context, value, ApiResultStatus>, debounceDurationInMs: number, waitBeforeRetryOnTransientFailure?: number) => Coroutine<context & value & {
-    lastUpdated: number;
-    dirty: DirtyStatus;
-    status: import("../../../main").Sum<DebouncedStatus, "debug off">;
-}, Debounced<value>, Unit>;
-//# sourceMappingURL=debounce.d.ts.map
+export declare const Debounce: <value, context = Unit>(
+  k: Coroutine<value & context, value, ApiResultStatus>,
+  debounceDurationInMs: number,
+  waitBeforeRetryOnTransientFailure?: number,
+) => Coroutine<
+  context &
+    value & {
+      lastUpdated: number;
+      dirty: DirtyStatus;
+      status: import("../../../main").Sum<DebouncedStatus, "debug off">;
+    },
+  Debounced<value>,
+  Unit
+>;
+//# sourceMappingURL=debounce.d.ts.map

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

@@ -1,28 +1,35 @@
 import { Sum } from "../../main";
 import { BasicUpdater, Updater } from "../fun/domains/updater/state";
 export type DirtyStatus = "dirty" | "not dirty" | "dirty but being processed";
-export type DebouncedStatus = "waiting for dirty" | "just detected dirty, starting processing" | "processing finished" | "state was still dirty but being processed, resetting to not dirty" | "processing shortcircuited" | "state was changed underwater back to dirty, leaving the dirty flag alone" | "inner call failed with transient failure";
+export type DebouncedStatus =
+  | "waiting for dirty"
+  | "just detected dirty, starting processing"
+  | "processing finished"
+  | "state was still dirty but being processed, resetting to not dirty"
+  | "processing shortcircuited"
+  | "state was changed underwater back to dirty, leaving the dirty flag alone"
+  | "inner call failed with transient failure";
 export type Debounced<Value> = Value & {
-    lastUpdated: number;
-    dirty: DirtyStatus;
-    status: Sum<DebouncedStatus, "debug off">;
+  lastUpdated: number;
+  dirty: DirtyStatus;
+  status: Sum<DebouncedStatus, "debug off">;
 };
 export declare const Debounced: {
-    Default: <v>(initialValue: v, debug?: boolean) => Debounced<v>;
-    Updaters: {
-        Core: {
-            status: <v>(_: BasicUpdater<DebouncedStatus>) => Updater<Debounced<v>>;
-            dirty: <v>(_: BasicUpdater<DirtyStatus>) => Updater<Debounced<v>>;
-            lastUpdated: <v>(_: BasicUpdater<number>) => Updater<Debounced<v>>;
-            valueWithoutDebouncing: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
-            value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
-        };
-        Template: {
-            value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
-        };
+  Default: <v>(initialValue: v, debug?: boolean) => Debounced<v>;
+  Updaters: {
+    Core: {
+      status: <v>(_: BasicUpdater<DebouncedStatus>) => Updater<Debounced<v>>;
+      dirty: <v>(_: BasicUpdater<DirtyStatus>) => Updater<Debounced<v>>;
+      lastUpdated: <v>(_: BasicUpdater<number>) => Updater<Debounced<v>>;
+      valueWithoutDebouncing: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+      value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
     };
-    Operations: {
-        shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
+    Template: {
+      value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
     };
+  };
+  Operations: {
+    shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/attachments/views/attachments-view.d.ts

@@ -1,8 +1,8 @@
 import { OrderedMap } from "immutable";
 import { Guid, SimpleCallback } from "../../../../../main";
 export declare const AttachmentsList: (props: {
-    attachments: OrderedMap<Guid, File>;
-    add: SimpleCallback<[Guid, File]>;
-    remove: SimpleCallback<Guid>;
+  attachments: OrderedMap<Guid, File>;
+  add: SimpleCallback<[Guid, File]>;
+  remove: SimpleCallback<Guid>;
 }) => import("react/jsx-runtime").JSX.Element;
-//# sourceMappingURL=attachments-view.d.ts.map
+//# sourceMappingURL=attachments-view.d.ts.map

package/bin/src/forms/domains/collection/domains/reference/state.d.ts

@@ -1,30 +1,37 @@
 export type CollectionReference = {
-    Id: string;
-    DisplayValue: string;
-    source?: "enum" | "stream";
+  Id: string;
+  DisplayValue: string;
+  source?: "enum" | "stream";
 };
 export declare const CollectionReference: {
-    Default: ((Id: string, DisplayValue: string, source?: "enum" | "stream") => CollectionReference) & {
-        empty: () => CollectionReference;
-    };
-    Updaters: {
-        DisplayValue: import("../../../../../../main").Widening<CollectionReference, "DisplayValue">;
-        Id: import("../../../../../../main").Widening<CollectionReference, "Id">;
-    };
-    Operations: {
-        IsCollectionReference: (value: any) => value is CollectionReference;
-    };
+  Default: ((
+    Id: string,
+    DisplayValue: string,
+    source?: "enum" | "stream",
+  ) => CollectionReference) & {
+    empty: () => CollectionReference;
+  };
+  Updaters: {
+    DisplayValue: import("../../../../../../main").Widening<
+      CollectionReference,
+      "DisplayValue"
+    >;
+    Id: import("../../../../../../main").Widening<CollectionReference, "Id">;
+  };
+  Operations: {
+    IsCollectionReference: (value: any) => value is CollectionReference;
+  };
 };
 export type EnumReference = {
-    Value: string;
+  Value: string;
 };
 export declare const EnumReference: {
-    Default: (value: string) => EnumReference;
-    Updaters: {
-        Value: import("../../../../../../main").Widening<EnumReference, "Value">;
-    };
-    Operations: {
-        IsEnumReference: (value: any) => value is EnumReference;
-    };
+  Default: (value: string) => EnumReference;
+  Updaters: {
+    Value: import("../../../../../../main").Widening<EnumReference, "Value">;
+  };
+  Operations: {
+    IsEnumReference: (value: any) => value is EnumReference;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/forms/domains/collection/domains/selection/state.d.ts

@@ -1,18 +1,40 @@
 import { Sum } from "../../../../../../main";
 import { CollectionReference, EnumReference } from "../reference/state";
-export type CollectionSelection<Element extends CollectionReference | EnumReference> = Sum<Element, "no selection">;
-export declare const CollectionSelection: <Element extends CollectionReference | EnumReference>() => {
-    Default: {
-        left: import("../../../../../fun/state").Fun<Element, Sum<Element, "no selection">>;
-        right: import("../../../../../fun/state").Fun<"no selection", Sum<Element, "no selection">>;
-    };
-    Updaters: {
-        left: import("../../../../../fun/state").Fun<import("../../../../../../main").BasicUpdater<Element>, import("../../../../../../main").Updater<Sum<Element, "no selection">>>;
-        right: import("../../../../../fun/state").Fun<import("../../../../../../main").BasicUpdater<"no selection">, import("../../../../../../main").Updater<Sum<Element, "no selection">>>;
-        map2: <a, b, a1, b1>(l: import("../../../../../fun/state").BasicFun<a, a1>, r: import("../../../../../fun/state").BasicFun<b, b1>) => import("../../../../../fun/state").Fun<Sum<a, b>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a, b_1, c>(l: import("../../../../../fun/state").BasicFun<a, c>, r: import("../../../../../fun/state").BasicFun<b_1, c>) => import("../../../../../fun/state").Fun<Sum<a, b_1>, c>;
-    };
+export type CollectionSelection<
+  Element extends CollectionReference | EnumReference,
+> = Sum<Element, "no selection">;
+export declare const CollectionSelection: <
+  Element extends CollectionReference | EnumReference,
+>() => {
+  Default: {
+    left: import("../../../../../fun/state").Fun<
+      Element,
+      Sum<Element, "no selection">
+    >;
+    right: import("../../../../../fun/state").Fun<
+      "no selection",
+      Sum<Element, "no selection">
+    >;
+  };
+  Updaters: {
+    left: import("../../../../../fun/state").Fun<
+      import("../../../../../../main").BasicUpdater<Element>,
+      import("../../../../../../main").Updater<Sum<Element, "no selection">>
+    >;
+    right: import("../../../../../fun/state").Fun<
+      import("../../../../../../main").BasicUpdater<"no selection">,
+      import("../../../../../../main").Updater<Sum<Element, "no selection">>
+    >;
+    map2: <a, b, a1, b1>(
+      l: import("../../../../../fun/state").BasicFun<a, a1>,
+      r: import("../../../../../fun/state").BasicFun<b, b1>,
+    ) => import("../../../../../fun/state").Fun<Sum<a, b>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a, b_1, c>(
+      l: import("../../../../../fun/state").BasicFun<a, c>,
+      r: import("../../../../../fun/state").BasicFun<b_1, c>,
+    ) => import("../../../../../fun/state").Fun<Sum<a, b_1>, c>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map