ballerina-core 1.0.199 → 1.0.201

package/bin/src/collections/domains/immutable/domains/orderedMap/state.d.ts

@@ -1,30 +1,58 @@
 import { OrderedMap } from "immutable";
-import { Identifiable, SmallIdentifiable } from "../../../../../baseEntity/domains/identifiable/state";
-import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import {
+  Identifiable,
+  SmallIdentifiable,
+} from "../../../../../baseEntity/domains/identifiable/state";
+import {
+  BasicUpdater,
+  Updater,
+} from "../../../../../fun/domains/updater/state";
 import { BasicFun } from "../../../../../fun/state";
 import { Unit } from "../../../../../../main";
 export declare const OrderedMapRepo: {
-    Default: {
-        fromSmallIdentifiables: <T extends SmallIdentifiable>(array: T[]) => OrderedMap<T["id"], T>;
-        fromIdentifiables: <T extends Identifiable>(array: T[]) => OrderedMap<T["Id"], T>;
-    };
-    Updaters: {
-        replaceAndMerge<K, V>(key: K, originalMap: OrderedMap<K, V>, mergeMap: OrderedMap<K, V>): OrderedMap<K, V>;
-        filter<K, V>(predicate: BasicFun<[K, V], boolean>): Updater<OrderedMap<K, V>>;
-        set<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
-        insertAtBeginning<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
-        insertAtEnd<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
-        insertAt<K, V>([key, value]: [K, V], insertionPosition: K, order: "before" | "after"): Updater<OrderedMap<K, V>>;
-        remove<K, V>(key: K): Updater<OrderedMap<K, V>>;
-        clear<K, V>(): Updater<OrderedMap<K, V>>;
-        merge<K, V>(key: K, originalMap: OrderedMap<K, V>, mergeMap: OrderedMap<K, V>): OrderedMap<K, V>;
-        update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<OrderedMap<k, v>>;
-        upsert: <k, v>(k: k, defaultValue: BasicFun<Unit, v>, _: BasicUpdater<v>) => Updater<OrderedMap<k, v>>;
-        append: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
-        prepend: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
-    };
-    Operations: {
-        toArray: <T extends Identifiable>(map: OrderedMap<T["Id"], T>) => T[];
-    };
+  Default: {
+    fromSmallIdentifiables: <T extends SmallIdentifiable>(
+      array: T[],
+    ) => OrderedMap<T["id"], T>;
+    fromIdentifiables: <T extends Identifiable>(
+      array: T[],
+    ) => OrderedMap<T["Id"], T>;
+  };
+  Updaters: {
+    replaceAndMerge<K, V>(
+      key: K,
+      originalMap: OrderedMap<K, V>,
+      mergeMap: OrderedMap<K, V>,
+    ): OrderedMap<K, V>;
+    filter<K, V>(
+      predicate: BasicFun<[K, V], boolean>,
+    ): Updater<OrderedMap<K, V>>;
+    set<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
+    insertAtBeginning<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
+    insertAtEnd<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
+    insertAt<K, V>(
+      [key, value]: [K, V],
+      insertionPosition: K,
+      order: "before" | "after",
+    ): Updater<OrderedMap<K, V>>;
+    remove<K, V>(key: K): Updater<OrderedMap<K, V>>;
+    clear<K, V>(): Updater<OrderedMap<K, V>>;
+    merge<K, V>(
+      key: K,
+      originalMap: OrderedMap<K, V>,
+      mergeMap: OrderedMap<K, V>,
+    ): OrderedMap<K, V>;
+    update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<OrderedMap<k, v>>;
+    upsert: <k, v>(
+      k: k,
+      defaultValue: BasicFun<Unit, v>,
+      _: BasicUpdater<v>,
+    ) => Updater<OrderedMap<k, v>>;
+    append: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
+    prepend: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
+  };
+  Operations: {
+    toArray: <T extends Identifiable>(map: OrderedMap<T["Id"], T>) => T[];
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/orderedMap/state.js

@@ -1,71 +1,90 @@
 import { OrderedMap } from "immutable";
-import { Updater, } from "../../../../../fun/domains/updater/state";
+import { Updater } from "../../../../../fun/domains/updater/state";
 export const OrderedMapRepo = {
-    Default: {
-        fromSmallIdentifiables: (array) => OrderedMap(array.reduce((acc, item) => {
-            acc[item.id] = item;
-            return acc;
-        }, {})),
-        fromIdentifiables: (array) => OrderedMap(array.reduce((acc, item) => {
-            acc[item.Id] = item;
-            return acc;
-        }, {})),
+  Default: {
+    fromSmallIdentifiables: (array) =>
+      OrderedMap(
+        array.reduce((acc, item) => {
+          acc[item.id] = item;
+          return acc;
+        }, {}),
+      ),
+    fromIdentifiables: (array) =>
+      OrderedMap(
+        array.reduce((acc, item) => {
+          acc[item.Id] = item;
+          return acc;
+        }, {}),
+      ),
+  },
+  Updaters: {
+    replaceAndMerge(key, originalMap, mergeMap) {
+      const index = originalMap.keySeq().findIndex((k) => k === key);
+      let newMap = originalMap.remove(key);
+      mergeMap.entrySeq().forEach((entry, idx) => {
+        newMap = newMap
+          .slice(0, index + idx)
+          .concat([[entry[0], entry[1]]], newMap.slice(index + idx));
+      });
+      return newMap;
     },
-    Updaters: {
-        replaceAndMerge(key, originalMap, mergeMap) {
-            const index = originalMap.keySeq().findIndex((k) => k === key);
-            let newMap = originalMap.remove(key);
-            mergeMap.entrySeq().forEach((entry, idx) => {
-                newMap = newMap
-                    .slice(0, index + idx)
-                    .concat([[entry[0], entry[1]]], newMap.slice(index + idx));
-            });
-            return newMap;
-        },
-        filter(predicate) {
-            return Updater((_) => _.filter((v, k) => predicate([k, v])));
-        },
-        set(key, value) {
-            return Updater((_) => _.set(key, value));
-        },
-        insertAtBeginning(key, value) {
-            return Updater((_) => OrderedMap(_.toArray().toSpliced(0, 0, [key, value])));
-        },
-        insertAtEnd(key, value) {
-            return Updater((_) => OrderedMap(_.toArray().toSpliced(_.size, 0, [key, value])));
-        },
-        insertAt([key, value], insertionPosition, order) {
-            return Updater((_) => {
-                const __ = _.toArray();
-                const insertionIndex = __.findIndex((value) => value[0] == insertionPosition) +
-                    (order == "after" ? 1 : 0);
-                return OrderedMap(__.toSpliced(insertionIndex, 0, [key, value]));
-            });
-        },
-        remove(key) {
-            return Updater((_) => _.remove(key));
-        },
-        clear() {
-            return Updater((_) => OrderedMap());
-        },
-        merge(key, originalMap, mergeMap) {
-            const index = originalMap.keySeq().findIndex((k) => k === key);
-            mergeMap.entrySeq().forEach((entry, idx) => {
-                originalMap = originalMap
-                    .slice(0, index + idx)
-                    .concat([[entry[0], entry[1]]], originalMap.slice(index + idx));
-            });
-            return originalMap;
-        },
-        update: (k, _) => Updater((current) => current.has(k) ? current.set(k, _(current.get(k))) : current),
-        upsert: (k, defaultValue, _) => Updater((current) => current.has(k)
-            ? current.set(k, _(current.get(k)))
-            : current.set(k, _(defaultValue({})))),
-        append: (newEntries) => Updater((current) => OrderedMap([...current.toArray(), ...newEntries])),
-        prepend: (newEntries) => Updater((current) => OrderedMap([...newEntries, ...current.toArray()])),
+    filter(predicate) {
+      return Updater((_) => _.filter((v, k) => predicate([k, v])));
     },
-    Operations: {
-        toArray: (map) => map.valueSeq().toArray(),
+    set(key, value) {
+      return Updater((_) => _.set(key, value));
     },
+    insertAtBeginning(key, value) {
+      return Updater((_) =>
+        OrderedMap(_.toArray().toSpliced(0, 0, [key, value])),
+      );
+    },
+    insertAtEnd(key, value) {
+      return Updater((_) =>
+        OrderedMap(_.toArray().toSpliced(_.size, 0, [key, value])),
+      );
+    },
+    insertAt([key, value], insertionPosition, order) {
+      return Updater((_) => {
+        const __ = _.toArray();
+        const insertionIndex =
+          __.findIndex((value) => value[0] == insertionPosition) +
+          (order == "after" ? 1 : 0);
+        return OrderedMap(__.toSpliced(insertionIndex, 0, [key, value]));
+      });
+    },
+    remove(key) {
+      return Updater((_) => _.remove(key));
+    },
+    clear() {
+      return Updater((_) => OrderedMap());
+    },
+    merge(key, originalMap, mergeMap) {
+      const index = originalMap.keySeq().findIndex((k) => k === key);
+      mergeMap.entrySeq().forEach((entry, idx) => {
+        originalMap = originalMap
+          .slice(0, index + idx)
+          .concat([[entry[0], entry[1]]], originalMap.slice(index + idx));
+      });
+      return originalMap;
+    },
+    update: (k, _) =>
+      Updater((current) =>
+        current.has(k) ? current.set(k, _(current.get(k))) : current,
+      ),
+    upsert: (k, defaultValue, _) =>
+      Updater((current) =>
+        current.has(k)
+          ? current.set(k, _(current.get(k)))
+          : current.set(k, _(defaultValue({}))),
+      ),
+    append: (newEntries) =>
+      Updater((current) => OrderedMap([...current.toArray(), ...newEntries])),
+    prepend: (newEntries) =>
+      Updater((current) => OrderedMap([...newEntries, ...current.toArray()])),
+  },
+  Operations: {
+    toArray: (map) => map.valueSeq().toArray(),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/immutable/domains/ordereredSet/state.d.ts

@@ -1,10 +1,10 @@
 import { Set } from "immutable";
 import { Updater } from "../../../../../fun/domains/updater/state";
 export declare const SetRepo: {
-    Updaters: {
-        add: <e>(e: e) => Updater<Set<e>>;
-        remove: <e>(e: e) => Updater<Set<e>>;
-        subtract: <e>(elements: Iterable<e>) => Updater<Set<e>>;
-    };
+  Updaters: {
+    add: <e>(e: e) => Updater<Set<e>>;
+    remove: <e>(e: e) => Updater<Set<e>>;
+    subtract: <e>(elements: Iterable<e>) => Updater<Set<e>>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/ordereredSet/state.js

@@ -1,9 +1,9 @@
 import { Updater } from "../../../../../fun/domains/updater/state";
 export const SetRepo = {
-    Updaters: {
-        add: (e) => Updater((current) => current.add(e)),
-        remove: (e) => Updater((current) => current.remove(e)),
-        subtract: (elements) => Updater((current) => current.subtract(elements)),
-    },
+  Updaters: {
+    add: (e) => Updater((current) => current.add(e)),
+    remove: (e) => Updater((current) => current.remove(e)),
+    subtract: (elements) => Updater((current) => current.subtract(elements)),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/maybe/state.d.ts

@@ -3,13 +3,13 @@ import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { BasicFun, Fun } from "../../../fun/state";
 export type Maybe<e> = e | undefined;
 export declare const Maybe: {
-    Default: <e>(_: e | undefined) => e | undefined;
-    Updaters: {
-        value: <e>(_: BasicUpdater<e>) => Updater<Maybe<e>>;
-        ensureValue: <e>(_: BasicFun<Unit, e>) => Updater<Maybe<e>>;
-    };
-    Operations: {
-        map: <a, b>(f: BasicFun<a, b>) => Fun<Maybe<a>, Maybe<b>>;
-    };
+  Default: <e>(_: e | undefined) => e | undefined;
+  Updaters: {
+    value: <e>(_: BasicUpdater<e>) => Updater<Maybe<e>>;
+    ensureValue: <e>(_: BasicFun<Unit, e>) => Updater<Maybe<e>>;
+  };
+  Operations: {
+    map: <a, b>(f: BasicFun<a, b>) => Fun<Maybe<a>, Maybe<b>>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/maybe/state.js

@@ -2,13 +2,16 @@ import { unit } from "../../../fun/domains/unit/state";
 import { Updater } from "../../../fun/domains/updater/state";
 import { Fun } from "../../../fun/state";
 export const Maybe = {
-    Default: (_) => _,
-    Updaters: {
-        value: (_) => Updater(Maybe.Operations.map(_)),
-        ensureValue: (_) => Updater((__) => (__ != undefined ? __ : _(unit))),
-    },
-    Operations: {
-        map: (f) => Fun((_) => _ != undefined ? Maybe.Default(f(_)) : Maybe.Default(undefined)),
-    },
+  Default: (_) => _,
+  Updaters: {
+    value: (_) => Updater(Maybe.Operations.map(_)),
+    ensureValue: (_) => Updater((__) => (__ != undefined ? __ : _(unit))),
+  },
+  Operations: {
+    map: (f) =>
+      Fun((_) =>
+        _ != undefined ? Maybe.Default(f(_)) : Maybe.Default(undefined),
+      ),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/product/state.d.ts

@@ -1,27 +1,33 @@
 import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { BasicFun, Fun } from "../../../fun/state";
 export type Product<a, b> = {
-    left: a;
-    right: b;
+  left: a;
+  right: b;
 };
 export type Pair<a, b> = Product<a, b>;
 export declare const Product: (<a, b>() => {
-    Default: (left: a, right: b) => Product<a, b>;
-    Updaters: {
-        left: Fun<BasicUpdater<a>, Updater<Product<a, b>>>;
-        right: Fun<BasicUpdater<b>, Updater<Product<a, b>>>;
-    };
-    Operations: {
-        map2: <a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Product<a, b>, Product<a1, b1>>;
-    };
+  Default: (left: a, right: b) => Product<a, b>;
+  Updaters: {
+    left: Fun<BasicUpdater<a>, Updater<Product<a, b>>>;
+    right: Fun<BasicUpdater<b>, Updater<Product<a, b>>>;
+  };
+  Operations: {
+    map2: <a1, b1>(
+      l: BasicFun<a, a1>,
+      r: BasicFun<b, b1>,
+    ) => Fun<Product<a, b>, Product<a1, b1>>;
+  };
 }) & {
-    Default: <a, b>(left: a, right: b) => Product<a, b>;
-    Updaters: {
-        left: <a, b>(_: BasicUpdater<a>) => Updater<Product<a, b>>;
-        right: <a, b>(_: BasicUpdater<b>) => Updater<Product<a, b>>;
-    };
-    Operations: {
-        map2: <a, b, a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Product<a, b>, Product<a1, b1>>;
-    };
+  Default: <a, b>(left: a, right: b) => Product<a, b>;
+  Updaters: {
+    left: <a, b>(_: BasicUpdater<a>) => Updater<Product<a, b>>;
+    right: <a, b>(_: BasicUpdater<b>) => Updater<Product<a, b>>;
+  };
+  Operations: {
+    map2: <a, b, a1, b1>(
+      l: BasicFun<a, a1>,
+      r: BasicFun<b, b1>,
+    ) => Fun<Product<a, b>, Product<a1, b1>>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/product/state.js

@@ -1,23 +1,26 @@
 import { id } from "../../../fun/domains/id/state";
 import { Updater } from "../../../fun/domains/updater/state";
 import { Fun } from "../../../fun/state";
-export const Product = Object.assign(() => ({
+export const Product = Object.assign(
+  () => ({
     Default: (left, right) => ({ left, right }),
     Updaters: {
-        left: Fun((_) => Updater(Product().Operations.map2(_, id))),
-        right: Fun((_) => Updater(Product().Operations.map2(id, _))),
+      left: Fun((_) => Updater(Product().Operations.map2(_, id))),
+      right: Fun((_) => Updater(Product().Operations.map2(id, _))),
     },
     Operations: {
-        map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
+      map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
     },
-}), {
+  }),
+  {
     Default: (left, right) => ({ left, right }),
     Updaters: {
-        left: (_) => Updater(Product().Operations.map2(_, id)),
-        right: (_) => Updater(Product().Operations.map2(id, _)),
+      left: (_) => Updater(Product().Operations.map2(_, id)),
+      right: (_) => Updater(Product().Operations.map2(id, _)),
     },
     Operations: {
-        map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
+      map2: (l, r) => Fun((_) => Product.Default(l(_.left), r(_.right))),
     },
-});
-//# sourceMappingURL=state.js.map
+  },
+);
+//# sourceMappingURL=state.js.map

package/bin/src/collections/domains/sum/state.d.ts

@@ -2,97 +2,121 @@ import { Unit } from "../../../fun/domains/unit/state";
 import { BasicUpdater, Updater } from "../../../fun/domains/updater/state";
 import { BasicFun, Fun } from "../../../fun/state";
 export type LeftValue<a> = {
-    value: a;
-    kind: "l";
+  value: a;
+  kind: "l";
 };
 export declare const LeftValue: {
-    Updaters: {
-        value: <a>(_: BasicUpdater<a>) => Updater<LeftValue<a>>;
-    };
+  Updaters: {
+    value: <a>(_: BasicUpdater<a>) => Updater<LeftValue<a>>;
+  };
 };
 export type RightValue<b> = {
-    value: b;
-    kind: "r";
+  value: b;
+  kind: "r";
 };
 export declare const RightValue: {
-    Updaters: {
-        value: <b>(_: BasicUpdater<b>) => Updater<RightValue<b>>;
-    };
-};
-export type Sum<a, b> = {
-    value: a;
-    kind: "l";
-} | {
-    value: b;
-    kind: "r";
+  Updaters: {
+    value: <b>(_: BasicUpdater<b>) => Updater<RightValue<b>>;
+  };
 };
+export type Sum<a, b> =
+  | {
+      value: a;
+      kind: "l";
+    }
+  | {
+      value: b;
+      kind: "r";
+    };
 export type Either<a, b> = Sum<a, b>;
 export type Option<a> = Sum<Unit, a>;
 export declare const Sum: (<a, b>() => {
-    Default: {
-        left: Fun<a, Sum<a, b>>;
-        right: Fun<b, Sum<a, b>>;
-    };
-    Updaters: {
-        left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
-        right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
-        map2: <a_1, b_1, a1, b1>(l: BasicFun<a_1, a1>, r: BasicFun<b_1, b1>) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a_1, b_2, c>(l: BasicFun<a_1, c>, r: BasicFun<b_2, c>) => Fun<Sum<a_1, b_2>, c>;
-    };
+  Default: {
+    left: Fun<a, Sum<a, b>>;
+    right: Fun<b, Sum<a, b>>;
+  };
+  Updaters: {
+    left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
+    right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
+    map2: <a_1, b_1, a1, b1>(
+      l: BasicFun<a_1, a1>,
+      r: BasicFun<b_1, b1>,
+    ) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a_1, b_2, c>(
+      l: BasicFun<a_1, c>,
+      r: BasicFun<b_2, c>,
+    ) => Fun<Sum<a_1, b_2>, c>;
+  };
 }) & {
-    Default: {
-        left: <a, b>(_: a) => Sum<a, b>;
-        right: <a, b>(_: b) => Sum<a, b>;
-    };
-    Updaters: {
-        left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
-        right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
-        map2: <a, b, a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Sum<a, b>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
-        ofOption: <a, b>(onNone: BasicFun<Unit, b>) => BasicFun<Option<a>, Sum<b, a>>;
-    };
+  Default: {
+    left: <a, b>(_: a) => Sum<a, b>;
+    right: <a, b>(_: b) => Sum<a, b>;
+  };
+  Updaters: {
+    left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
+    right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
+    map2: <a, b, a1, b1>(
+      l: BasicFun<a, a1>,
+      r: BasicFun<b, b1>,
+    ) => Fun<Sum<a, b>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
+    ofOption: <a, b>(
+      onNone: BasicFun<Unit, b>,
+    ) => BasicFun<Option<a>, Sum<b, a>>;
+  };
 };
 export declare const Either: (<a, b>() => {
-    Default: {
-        left: Fun<a, Sum<a, b>>;
-        right: Fun<b, Sum<a, b>>;
-    };
-    Updaters: {
-        left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
-        right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
-        map2: <a_1, b_1, a1, b1>(l: BasicFun<a_1, a1>, r: BasicFun<b_1, b1>) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a_1, b_2, c>(l: BasicFun<a_1, c>, r: BasicFun<b_2, c>) => Fun<Sum<a_1, b_2>, c>;
-    };
+  Default: {
+    left: Fun<a, Sum<a, b>>;
+    right: Fun<b, Sum<a, b>>;
+  };
+  Updaters: {
+    left: Fun<BasicUpdater<a>, Updater<Sum<a, b>>>;
+    right: Fun<BasicUpdater<b>, Updater<Sum<a, b>>>;
+    map2: <a_1, b_1, a1, b1>(
+      l: BasicFun<a_1, a1>,
+      r: BasicFun<b_1, b1>,
+    ) => Fun<Sum<a_1, b_1>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a_1, b_2, c>(
+      l: BasicFun<a_1, c>,
+      r: BasicFun<b_2, c>,
+    ) => Fun<Sum<a_1, b_2>, c>;
+  };
 }) & {
-    Default: {
-        left: <a, b>(_: a) => Sum<a, b>;
-        right: <a, b>(_: b) => Sum<a, b>;
-    };
-    Updaters: {
-        left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
-        right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
-        map2: <a, b, a1, b1>(l: BasicFun<a, a1>, r: BasicFun<b, b1>) => Fun<Sum<a, b>, Sum<a1, b1>>;
-    };
-    Operations: {
-        fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
-        ofOption: <a, b>(onNone: BasicFun<Unit, b>) => BasicFun<Option<a>, Sum<b, a>>;
-    };
+  Default: {
+    left: <a, b>(_: a) => Sum<a, b>;
+    right: <a, b>(_: b) => Sum<a, b>;
+  };
+  Updaters: {
+    left: <a, b>(_: BasicUpdater<a>) => Updater<Sum<a, b>>;
+    right: <a, b>(_: BasicUpdater<b>) => Updater<Sum<a, b>>;
+    map2: <a, b, a1, b1>(
+      l: BasicFun<a, a1>,
+      r: BasicFun<b, b1>,
+    ) => Fun<Sum<a, b>, Sum<a1, b1>>;
+  };
+  Operations: {
+    fold: <a, b, c>(l: BasicFun<a, c>, r: BasicFun<b, c>) => Fun<Sum<a, b>, c>;
+    ofOption: <a, b>(
+      onNone: BasicFun<Unit, b>,
+    ) => BasicFun<Option<a>, Sum<b, a>>;
+  };
 };
 export declare const Option: {
-    Default: {
-        none: <a>() => Option<a>;
-        some: <a>(_: a) => Option<a>;
-    };
-    Updaters: {
-        none: <a>() => Updater<Option<a>>;
-        some: <a>(_: BasicUpdater<a>) => Updater<Option<a>>;
-        map2: <a, a1>(some: BasicFun<a, a1>) => Fun<Option<a>, Option<a1>>;
-    };
+  Default: {
+    none: <a>() => Option<a>;
+    some: <a>(_: a) => Option<a>;
+  };
+  Updaters: {
+    none: <a>() => Updater<Option<a>>;
+    some: <a>(_: BasicUpdater<a>) => Updater<Option<a>>;
+    map2: <a, a1>(some: BasicFun<a, a1>) => Fun<Option<a>, Option<a1>>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map