ballerina-core 1.0.243 → 1.0.244

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

@@ -6,204 +6,89 @@ 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,24 +3,15 @@ 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,18 +2,9 @@ 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,35 +1,28 @@
 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>>;
+    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>>;
+        };
     };
-    Template: {
-      value: <v>(_: BasicUpdater<v>) => Updater<Debounced<v>>;
+    Operations: {
+        shouldCoroutineRun: <v>(_: Debounced<v>) => boolean;
     };
-  };
-  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,37 +1,30 @@
 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,40 +1,18 @@
 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