ballerina-core 1.0.245 → 1.0.246

package/bin/src/fun/domains/predicate/domains/bool-expr.js

@@ -1,84 +1,75 @@
 import { Predicate } from "../state";
 export const BoolExpr = {
-  Default: Object.assign(
-    (_) => {
-      return Object.assign(
-        typeof _ == "boolean"
-          ? { kind: _ ? "true" : "false" }
-          : _.kind == "and" || _.kind == "or"
-            ? {
-                kind: _.kind,
-                operands: [
-                  BoolExpr.Default(_.operands[0]),
-                  BoolExpr.Default(_.operands[1]),
-                ],
-              }
-            : _.kind == "not"
-              ? { kind: _.kind, operand: BoolExpr.Default(_.operand) }
-              : _.kind == "leaf"
+    Default: Object.assign((_) => {
+        return Object.assign(typeof _ == "boolean"
+            ? { kind: _ ? "true" : "false" }
+            : _.kind == "and" || _.kind == "or"
                 ? {
                     kind: _.kind,
-                    operation: _.operation,
-                    arguments: _.arguments,
-                  }
-                : _.kind == "true"
-                  ? { kind: _.kind }
-                  : { kind: _.kind },
-        {
-          not: function () {
-            return BoolExpr.Default({
-              kind: "not",
-              operand: this,
-            });
-          },
-          and: function (other) {
-            return BoolExpr.Default({
-              kind: "and",
-              operands: [this, other],
-            });
-          },
-          or: function (other) {
-            return BoolExpr.Default({
-              kind: "or",
-              operands: [this, other],
-            });
-          },
-          eval: function (evalLeaf) {
-            return this.kind == "not"
-              ? this.operand.eval(evalLeaf).not()
-              : this.kind == "and"
-                ? this.operands[0]
-                    .eval(evalLeaf)
-                    .and(this.operands[1].eval(evalLeaf))
-                : this.kind == "or"
-                  ? this.operands[0]
-                      .eval(evalLeaf)
-                      .or(this.operands[1].eval(evalLeaf))
-                  : this.kind == "leaf"
-                    ? evalLeaf[this.operation](this.arguments)
-                    : this.kind == "true"
-                      ? Predicate.True()
-                      : Predicate.False();
-          },
-        },
-      );
-    },
-    {
-      true: () =>
-        BoolExpr.Default({
-          kind: "true",
+                    operands: [
+                        BoolExpr.Default(_.operands[0]),
+                        BoolExpr.Default(_.operands[1]),
+                    ],
+                }
+                : _.kind == "not"
+                    ? { kind: _.kind, operand: BoolExpr.Default(_.operand) }
+                    : _.kind == "leaf"
+                        ? {
+                            kind: _.kind,
+                            operation: _.operation,
+                            arguments: _.arguments,
+                        }
+                        : _.kind == "true"
+                            ? { kind: _.kind }
+                            : { kind: _.kind }, {
+            not: function () {
+                return BoolExpr.Default({
+                    kind: "not",
+                    operand: this,
+                });
+            },
+            and: function (other) {
+                return BoolExpr.Default({
+                    kind: "and",
+                    operands: [this, other],
+                });
+            },
+            or: function (other) {
+                return BoolExpr.Default({
+                    kind: "or",
+                    operands: [this, other],
+                });
+            },
+            eval: function (evalLeaf) {
+                return this.kind == "not"
+                    ? this.operand.eval(evalLeaf).not()
+                    : this.kind == "and"
+                        ? this.operands[0]
+                            .eval(evalLeaf)
+                            .and(this.operands[1].eval(evalLeaf))
+                        : this.kind == "or"
+                            ? this.operands[0]
+                                .eval(evalLeaf)
+                                .or(this.operands[1].eval(evalLeaf))
+                            : this.kind == "leaf"
+                                ? evalLeaf[this.operation](this.arguments)
+                                : this.kind == "true"
+                                    ? Predicate.True()
+                                    : Predicate.False();
+            },
+        });
+    }, {
+        true: () => BoolExpr.Default({
+            kind: "true",
         }),
-      false: () =>
-        BoolExpr.Default({
-          kind: "false",
+        false: () => BoolExpr.Default({
+            kind: "false",
         }),
-      leaf: () => (operation, args) =>
-        BoolExpr.Default({
-          kind: "leaf",
-          operation,
-          arguments: args,
+        leaf: () => (operation, args) => BoolExpr.Default({
+            kind: "leaf",
+            operation,
+            arguments: args,
         }),
-    },
-  ),
+    }),
 };
-//# sourceMappingURL=bool-expr.js.map
+//# sourceMappingURL=bool-expr.js.map

package/bin/src/fun/domains/predicate/state.d.ts

@@ -1,14 +1,12 @@
 import { BasicFun, Fun } from "../../state";
 export type BasicPredicate<c> = BasicFun<c, boolean>;
 export type Predicate<c> = Fun<c, boolean> & {
-  not: () => Predicate<c>;
-  and: (other: Predicate<c>) => Predicate<c>;
-  or: (other: Predicate<c>) => Predicate<c>;
+    not: () => Predicate<c>;
+    and: (other: Predicate<c>) => Predicate<c>;
+    or: (other: Predicate<c>) => Predicate<c>;
 };
-export declare const Predicate: (<c>(
-  actual: BasicPredicate<c>,
-) => Predicate<c>) & {
-  True: <c>() => Predicate<c>;
-  False: <c>() => Predicate<c>;
+export declare const Predicate: (<c>(actual: BasicPredicate<c>) => Predicate<c>) & {
+    True: <c>() => Predicate<c>;
+    False: <c>() => Predicate<c>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/predicate/state.js

@@ -1,20 +1,16 @@
 import { Fun } from "../../state";
-export const Predicate = Object.assign(
-  (actual) =>
-    Object.assign(Fun(actual), {
-      not: function () {
+export const Predicate = Object.assign((actual) => Object.assign(Fun(actual), {
+    not: function () {
         return Predicate((_) => !this(_));
-      },
-      and: function (other) {
+    },
+    and: function (other) {
         return Predicate((_) => this(_) && other(_));
-      },
-      or: function (other) {
+    },
+    or: function (other) {
         return Predicate((_) => this(_) || other(_));
-      },
-    }),
-  {
+    },
+}), {
     True: () => Predicate((_) => true),
     False: () => Predicate((_) => false),
-  },
-);
-//# sourceMappingURL=state.js.map
+});
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/simpleCallback/state.d.ts

@@ -1,3 +1,3 @@
 import { BasicFun } from "../../state";
 export type SimpleCallback<E = void> = BasicFun<E, void>;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/simpleCallback/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/uncurry/state.d.ts

@@ -1,4 +1,2 @@
-export declare const uncurry: <A, B, C>(
-  f: (a: A) => (b: B) => C,
-) => (a: A, b: B) => C;
-//# sourceMappingURL=state.d.ts.map
+export declare const uncurry: <A, B, C>(f: (a: A) => (b: B) => C) => (a: A, b: B) => C;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/uncurry/state.js

@@ -1,2 +1,2 @@
 export const uncurry = (f) => (a, b) => f(a)(b);
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/unit/state.d.ts

@@ -1,3 +1,3 @@
 export type Unit = {};
 export declare const unit: Unit;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/unit/state.js

@@ -1,2 +1,2 @@
 export const unit = {}; // { kind:"unit" };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/caseUpdater/state.d.ts

@@ -1,27 +1,12 @@
 import { BasicFun } from "../../../../state";
 import { BasicUpdater, Updater } from "../../state";
 export type Kind<T> = T extends {
-  kind: infer k;
-}
-  ? k
-  : never;
-export type CaseUpdater<
-  Entity,
-  Field extends keyof Entity,
-  CaseName extends Kind<Entity[Field]> & string,
-> = {
-  [f in CaseName]: BasicFun<
-    BasicUpdater<
-      Entity[Field] & {
+    kind: infer k;
+} ? k : never;
+export type CaseUpdater<Entity, Field extends keyof Entity, CaseName extends Kind<Entity[Field]> & string> = {
+    [f in CaseName]: BasicFun<BasicUpdater<Entity[Field] & {
         kind: CaseName;
-      }
-    >,
-    Updater<Entity>
-  >;
+    }>, Updater<Entity>>;
 };
-export declare const caseUpdater: <Entity>() => <Field extends keyof Entity>(
-  field: Field,
-) => <CaseName extends Kind<Entity[Field]> & string>(
-  caseName: CaseName,
-) => CaseUpdater<Entity, Field, CaseName>;
-//# sourceMappingURL=state.d.ts.map
+export declare const caseUpdater: <Entity>() => <Field extends keyof Entity>(field: Field) => <CaseName extends Kind<Entity[Field]> & string>(caseName: CaseName) => CaseUpdater<Entity, Field, CaseName>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/caseUpdater/state.js

@@ -1,29 +1,21 @@
 import { Updater } from "../../state";
 export const caseUpdater = () => (field) => (caseName) => ({
-  [caseName]: (caseUpdater) => {
-    return Updater((currentEntity) =>
-      currentEntity[field].kind == caseName
-        ? Object.assign(Object.assign({}, currentEntity), {
-            [field]: caseUpdater(currentEntity),
-          })
-        : currentEntity,
-    );
-  },
+    [caseName]: (caseUpdater) => {
+        return Updater((currentEntity) => currentEntity[field].kind == caseName
+            ? Object.assign(Object.assign({}, currentEntity), { [field]: caseUpdater(currentEntity) }) : currentEntity);
+    },
 });
-import { Sum } from "../../../../../collections/domains/sum/state";
+import { Sum, } from "../../../../../collections/domains/sum/state";
 const Y = Sum();
 const X = {
-  Default: () => ({ y: Y.Default.left(10) }),
-  Updaters: {
-    y: Object.assign(
-      Object.assign({}, caseUpdater()("y")("l")),
-      caseUpdater()("y")("r"),
-    ),
-  },
+    Default: () => ({ y: Y.Default.left(10) }),
+    Updaters: {
+        y: Object.assign(Object.assign({}, caseUpdater()("y")("l")), caseUpdater()("y")("r")),
+    },
 };
 // const visitor =
 //   X.Updaters.y.l(LeftValue.Updaters.value(_ => _ + 1)).then(
 //     X.Updaters.y.r(RightValue.Updaters.value(_ => !_))
 //   )
 // console.log(visitor)
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/mapUpdater/state.d.ts

@@ -2,30 +2,19 @@ import { BasicFun, Fun } from "../../../../state";
 import { Unit } from "../../../unit/state";
 import { BasicUpdater, Updater } from "../../state";
 import { Map } from "immutable";
-export type MapUpdater<
-  Entity,
-  Field extends keyof Entity,
-  DisplayName extends string,
-> = Entity extends {
-  [_ in Field]: Map<infer key, infer value>;
-}
-  ? {
-      [f in DisplayName]: {
+export type MapUpdater<Entity, Field extends keyof Entity, DisplayName extends string> = Entity extends {
+    [_ in Field]: Map<infer key, infer value>;
+} ? {
+    [f in DisplayName]: {
         add: Fun<[key, value], Updater<Entity>>;
         remove: Fun<key, Updater<Entity>>;
         set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
-        upsert: Fun<
-          [key, BasicFun<Unit, value>, BasicUpdater<value>],
-          Updater<Entity>
-        >;
-      };
-    }
-  : "Error: mapUpdater has been invoked on a field which is not a map";
-export declare const mapUpdater: <Entity>() => <
-  Field extends keyof Entity,
-  DisplayName extends string,
->(
-  field: Field,
-  displayName: DisplayName,
-) => MapUpdater<Entity, Field, DisplayName>;
-//# sourceMappingURL=state.d.ts.map
+        upsert: Fun<[
+            key,
+            BasicFun<Unit, value>,
+            BasicUpdater<value>
+        ], Updater<Entity>>;
+    };
+} : "Error: mapUpdater has been invoked on a field which is not a map";
+export declare const mapUpdater: <Entity>() => <Field extends keyof Entity, DisplayName extends string>(field: Field, displayName: DisplayName) => MapUpdater<Entity, Field, DisplayName>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/mapUpdater/state.js

@@ -2,45 +2,15 @@ import { Fun } from "../../../../state";
 import { unit } from "../../../unit/state";
 import { Updater } from "../../state";
 export const mapUpdater = () => (field, displayName) => ({
-  [displayName]: {
-    add: Fun(([key, value]) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].set(key, value),
-        }),
-      ),
-    ),
-    remove: Fun((key) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].remove(key),
-        }),
-      ),
-    ),
-    set: Fun((key) =>
-      Fun((fieldUpdater) =>
-        Updater((entity) =>
-          Object.assign(Object.assign({}, entity), {
-            [field]:
-              entity[field].has(key) == false
+    [displayName]: {
+        add: Fun(([key, value]) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].set(key, value) })))),
+        remove: Fun((key) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].remove(key) })))),
+        set: Fun((key) => Fun((fieldUpdater) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].has(key) == false
                 ? entity[field]
-                : entity[field].set(key, fieldUpdater(entity[field].get(key))),
-          }),
-        ),
-      ),
-    ),
-    upsert: Fun(([key, fallback, fieldUpdater]) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].set(
-            key,
-            entity[field].has(key)
-              ? fieldUpdater(entity[field].get(key))
-              : fieldUpdater(fallback(unit)),
-          ),
-        }),
-      ),
-    ),
-  },
+                : entity[field].set(key, fieldUpdater(entity[field].get(key))) }))))),
+        upsert: Fun(([key, fallback, fieldUpdater]) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].set(key, entity[field].has(key)
+                ? fieldUpdater(entity[field].get(key))
+                : fieldUpdater(fallback(unit))) })))),
+    },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/maybeUpdater/state.d.ts

@@ -1,23 +1,17 @@
 import { Fun } from "../../../../state";
 import { BasicUpdater, Updater } from "../../state";
 export type MaybeUpdater<Entity, Field extends keyof Entity> = Entity extends {
-  [_ in Field]: infer value | undefined;
-}
-  ? Required<{
-      [f in Field]: Fun<BasicUpdater<value>, Updater<Entity>> & {
+    [_ in Field]: infer value | undefined;
+} ? Required<{
+    [f in Field]: Fun<BasicUpdater<value>, Updater<Entity>> & {
         both: Fun<BasicUpdater<value | undefined>, Updater<Entity>>;
-      };
-    }>
-  : Entity extends {
-        [_ in Field]?: infer value;
-      }
-    ? Required<{
-        [f in Field]: Fun<BasicUpdater<value>, Updater<Entity>> & {
-          both: Fun<BasicUpdater<value | undefined>, Updater<Entity>>;
-        };
-      }>
-    : "Error: maybeUpdater has been invoked on a field which cannot be undefined";
-export declare const maybeUpdater: <Entity>() => <Field extends keyof Entity>(
-  field: Field,
-) => MaybeUpdater<Entity, Field>;
-//# sourceMappingURL=state.d.ts.map
+    };
+}> : Entity extends {
+    [_ in Field]?: infer value;
+} ? Required<{
+    [f in Field]: Fun<BasicUpdater<value>, Updater<Entity>> & {
+        both: Fun<BasicUpdater<value | undefined>, Updater<Entity>>;
+    };
+}> : "Error: maybeUpdater has been invoked on a field which cannot be undefined";
+export declare const maybeUpdater: <Entity>() => <Field extends keyof Entity>(field: Field) => MaybeUpdater<Entity, Field>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/maybeUpdater/state.js

@@ -1,26 +1,15 @@
 import { Fun } from "../../../../state";
 import { Updater } from "../../state";
 export const maybeUpdater = () => (field) => ({
-  [field]: Object.assign(
-    Fun((fieldUpdater) => {
-      return Updater((currentEntity) =>
-        currentEntity[field] == undefined
-          ? currentEntity
-          : Object.assign(Object.assign({}, currentEntity), {
-              [field]: fieldUpdater(currentEntity[field]),
-            }),
-      );
+    [field]: Object.assign(Fun((fieldUpdater) => {
+        return Updater((currentEntity) => currentEntity[field] == undefined
+            ? currentEntity
+            : Object.assign(Object.assign({}, currentEntity), { [field]: fieldUpdater(currentEntity[field]) }));
+    }), {
+        both: Fun((fieldUpdater) => {
+            return Updater((currentEntity) => (Object.assign(Object.assign({}, currentEntity), { [field]: fieldUpdater(currentEntity[field]) })));
+        }),
     }),
-    {
-      both: Fun((fieldUpdater) => {
-        return Updater((currentEntity) =>
-          Object.assign(Object.assign({}, currentEntity), {
-            [field]: fieldUpdater(currentEntity[field]),
-          }),
-        );
-      }),
-    },
-  ),
 });
 // // reference examples:
 // type T = {
@@ -35,4 +24,4 @@ export const maybeUpdater = () => (field) => ({
 //     ...maybeUpdater<T>()("z").z.both(...),
 //   }
 // }
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/orderedMapUpdater/state.d.ts

@@ -2,31 +2,20 @@ import { BasicFun, Fun } from "../../../../state";
 import { Unit } from "../../../unit/state";
 import { BasicUpdater, Updater } from "../../state";
 import { OrderedMap } from "immutable";
-export type OrderedMapUpdater<
-  Entity,
-  Field extends keyof Entity,
-  DisplayName extends string,
-> = Entity extends {
-  [_ in Field]: OrderedMap<infer key, infer value>;
-}
-  ? {
-      [f in DisplayName]: {
+export type OrderedMapUpdater<Entity, Field extends keyof Entity, DisplayName extends string> = Entity extends {
+    [_ in Field]: OrderedMap<infer key, infer value>;
+} ? {
+    [f in DisplayName]: {
         add: Fun<[key, value], Updater<Entity>>;
         remove: Fun<key, Updater<Entity>>;
         concat: Fun<OrderedMap<key, value>, Updater<Entity>>;
         set: Fun<key, Fun<BasicUpdater<value>, Updater<Entity>>>;
-        upsert: Fun<
-          [key, BasicFun<Unit, value>, BasicUpdater<value>],
-          Updater<Entity>
-        >;
-      };
-    }
-  : "Error: orderedMapUpdater has been invoked on a field which is not an OrderedMap";
-export declare const orderedMapUpdater: <Entity>() => <
-  Field extends keyof Entity,
-  DisplayName extends string,
->(
-  field: Field,
-  displayName: DisplayName,
-) => OrderedMapUpdater<Entity, Field, DisplayName>;
-//# sourceMappingURL=state.d.ts.map
+        upsert: Fun<[
+            key,
+            BasicFun<Unit, value>,
+            BasicUpdater<value>
+        ], Updater<Entity>>;
+    };
+} : "Error: orderedMapUpdater has been invoked on a field which is not an OrderedMap";
+export declare const orderedMapUpdater: <Entity>() => <Field extends keyof Entity, DisplayName extends string>(field: Field, displayName: DisplayName) => OrderedMapUpdater<Entity, Field, DisplayName>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/orderedMapUpdater/state.js

@@ -2,52 +2,16 @@ import { Fun } from "../../../../state";
 import { unit } from "../../../unit/state";
 import { Updater } from "../../state";
 export const orderedMapUpdater = () => (field, displayName) => ({
-  [displayName]: {
-    add: Fun(([key, value]) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].set(key, value),
-        }),
-      ),
-    ),
-    remove: Fun((key) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].remove(key),
-        }),
-      ),
-    ),
-    concat: Fun((other) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].concat(other),
-        }),
-      ),
-    ),
-    set: Fun((key) =>
-      Fun((fieldUpdater) =>
-        Updater((entity) =>
-          Object.assign(Object.assign({}, entity), {
-            [field]:
-              entity[field].has(key) == false
+    [displayName]: {
+        add: Fun(([key, value]) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].set(key, value) })))),
+        remove: Fun((key) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].remove(key) })))),
+        concat: Fun((other) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].concat(other) })))),
+        set: Fun((key) => Fun((fieldUpdater) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].has(key) == false
                 ? entity[field]
-                : entity[field].set(key, fieldUpdater(entity[field].get(key))),
-          }),
-        ),
-      ),
-    ),
-    upsert: Fun(([key, fallback, fieldUpdater]) =>
-      Updater((entity) =>
-        Object.assign(Object.assign({}, entity), {
-          [field]: entity[field].set(
-            key,
-            entity[field].has(key)
-              ? fieldUpdater(entity[field].get(key))
-              : fieldUpdater(fallback(unit)),
-          ),
-        }),
-      ),
-    ),
-  },
+                : entity[field].set(key, fieldUpdater(entity[field].get(key))) }))))),
+        upsert: Fun(([key, fallback, fieldUpdater]) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].set(key, entity[field].has(key)
+                ? fieldUpdater(entity[field].get(key))
+                : fieldUpdater(fallback(unit))) })))),
+    },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/orderedSetUpdater/state.d.ts

@@ -1,25 +1,13 @@
 import { Fun } from "../../../../state";
 import { Updater } from "../../state";
 import { OrderedSet } from "immutable";
-export type OrderedSetUpdater<
-  Entity,
-  Field extends keyof Entity,
-  DisplayName extends string,
-> = Entity extends {
-  [_ in Field]: OrderedSet<infer value>;
-}
-  ? {
-      [f in DisplayName]: {
+export type OrderedSetUpdater<Entity, Field extends keyof Entity, DisplayName extends string> = Entity extends {
+    [_ in Field]: OrderedSet<infer value>;
+} ? {
+    [f in DisplayName]: {
         add: Fun<value, Updater<Entity>>;
         remove: Fun<value, Updater<Entity>>;
-      };
-    }
-  : "Error: orderedSetUpdater has been invoked on a filed which is not an OrderedSet";
-export declare const orderedSetUpdater: <Entity>() => <
-  Field extends keyof Entity,
-  DisplayName extends string,
->(
-  field: Field,
-  displayName: DisplayName,
-) => OrderedSetUpdater<Entity, Field, DisplayName>;
-//# sourceMappingURL=state.d.ts.map
+    };
+} : "Error: orderedSetUpdater has been invoked on a filed which is not an OrderedSet";
+export declare const orderedSetUpdater: <Entity>() => <Field extends keyof Entity, DisplayName extends string>(field: Field, displayName: DisplayName) => OrderedSetUpdater<Entity, Field, DisplayName>;
+//# sourceMappingURL=state.d.ts.map