ballerina-core 1.0.200 → 1.0.201

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

@@ -1,75 +1,84 @@
 import { Predicate } from "../state";
 export const BoolExpr = {
-    Default: Object.assign((_) => {
-        return Object.assign(typeof _ == "boolean"
-            ? { kind: _ ? "true" : "false" }
-            : _.kind == "and" || _.kind == "or"
+  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"
                 ? {
                     kind: _.kind,
-                    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",
+                    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,12 +1,14 @@
 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,16 +1,20 @@
 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,2 +1,4 @@
-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,12 +1,27 @@
 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,21 +1,29 @@
 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,19 +2,30 @@ 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,15 +2,45 @@ 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,17 +1,23 @@
 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,15 +1,26 @@
 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]) }));
-    }), {
-        both: Fun((fieldUpdater) => {
-            return Updater((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]),
+          }),
+        );
+      }),
+    },
+  ),
 });
 // // reference examples:
 // type T = {
@@ -24,4 +35,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,20 +2,31 @@ 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,16 +2,52 @@ 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,13 +1,25 @@
 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