ballerina-core 1.0.199 → 1.0.201

package/bin/main.d.ts

@@ -214,4 +214,4 @@ export * from "./src/forms/domains/dispatched-forms/built-ins/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/dispatcher/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/abstract-renderers/injectables/state";
 export * from "./src/forms/domains/dispatched-forms/runner/domains/traversal/state";
-//# sourceMappingURL=main.d.ts.map
+//# sourceMappingURL=main.d.ts.map

package/bin/main.js

@@ -263,4 +263,4 @@ export * from "./src/forms/domains/dispatched-forms/runner/domains/traversal/sta
 // console.log(personUpdater(Person.Default()))
 // const addressUpdater:Updater<Address> = Address.Updaters.Core.city.children.name(_ =>"The Great " + _)
 // console.log(addressUpdater(Address.Default()))
-//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map

package/bin/src/api-response-handler/coroutines/runner.d.ts

@@ -1,4 +1,11 @@
 import { ApiResponseHandler } from "../state";
 import { AsyncState } from "../../../main";
-export declare const HandleApiResponse: <State, Context, ApiErrors>(asyncAccessor: (_: State & Context) => AsyncState<ApiErrors>, handlers: ApiResponseHandler<State & Context, ApiErrors>) => import("../../coroutines/state").Coroutine<Context & State, State, import("../../../main").Unit>;
-//# sourceMappingURL=runner.d.ts.map
+export declare const HandleApiResponse: <State, Context, ApiErrors>(
+  asyncAccessor: (_: State & Context) => AsyncState<ApiErrors>,
+  handlers: ApiResponseHandler<State & Context, ApiErrors>,
+) => import("../../coroutines/state").Coroutine<
+  Context & State,
+  State,
+  import("../../../main").Unit
+>;
+//# sourceMappingURL=runner.d.ts.map

package/bin/src/api-response-handler/coroutines/runner.js

@@ -1,17 +1,24 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 import { AsyncState } from "../../../main";
 export const HandleApiResponse = (asyncAccessor, handlers) => {
-    const CheckerCo = CoTypedFactory();
-    return CheckerCo.GetState().then((_) => {
-        const asyncState = asyncAccessor(_);
-        return AsyncState.Operations.isLoading(asyncState)
-            ? CheckerCo.Do(() => { })
-            : CheckerCo.Do(() => {
-                var _a, _b;
-                return AsyncState.Operations.status(asyncState) === "error"
-                    ? (_a = handlers.handleError) === null || _a === void 0 ? void 0 : _a.call(handlers, asyncState.kind === "error" ? asyncState.error : undefined)
-                    : (_b = handlers.handleSuccess) === null || _b === void 0 ? void 0 : _b.call(handlers, _);
-            });
-    });
+  const CheckerCo = CoTypedFactory();
+  return CheckerCo.GetState().then((_) => {
+    const asyncState = asyncAccessor(_);
+    return AsyncState.Operations.isLoading(asyncState)
+      ? CheckerCo.Do(() => {})
+      : CheckerCo.Do(() => {
+          var _a, _b;
+          return AsyncState.Operations.status(asyncState) === "error"
+            ? (_a = handlers.handleError) === null || _a === void 0
+              ? void 0
+              : _a.call(
+                  handlers,
+                  asyncState.kind === "error" ? asyncState.error : undefined,
+                )
+            : (_b = handlers.handleSuccess) === null || _b === void 0
+              ? void 0
+              : _b.call(handlers, _);
+        });
+  });
 };
-//# sourceMappingURL=runner.js.map
+//# sourceMappingURL=runner.js.map

package/bin/src/api-response-handler/state.d.ts

@@ -1,19 +1,19 @@
 import { BasicUpdater } from "../../main";
 export type ApiResponseHandler<response, errors> = {
-    handleSuccess?: (_?: response) => void;
-    handleError?: (_?: errors) => void;
+  handleSuccess?: (_?: response) => void;
+  handleError?: (_?: errors) => void;
 };
 export type ApiResponseChecker = {
-    apiResponseChecked: boolean;
+  apiResponseChecked: boolean;
 };
 export declare const ApiResponseChecker: {
-    Default: (_?: boolean) => ApiResponseChecker;
-    Updaters: <CheckedState extends ApiResponseChecker>() => {
-        toChecked: () => BasicUpdater<CheckedState>;
-        toUnchecked: () => BasicUpdater<CheckedState>;
-    };
-    Operations: {
-        checked: (_: ApiResponseChecker) => boolean;
-    };
+  Default: (_?: boolean) => ApiResponseChecker;
+  Updaters: <CheckedState extends ApiResponseChecker>() => {
+    toChecked: () => BasicUpdater<CheckedState>;
+    toUnchecked: () => BasicUpdater<CheckedState>;
+  };
+  Operations: {
+    checked: (_: ApiResponseChecker) => boolean;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/api-response-handler/state.js

@@ -1,13 +1,15 @@
 export const ApiResponseChecker = {
-    Default: (_) => ({
-        apiResponseChecked: _ !== null && _ !== void 0 ? _ : false,
-    }),
-    Updaters: () => ({
-        toChecked: () => (_) => (Object.assign(Object.assign({}, _), { apiResponseChecked: true })),
-        toUnchecked: () => (_) => (Object.assign(Object.assign({}, _), { apiResponseChecked: false })),
-    }),
-    Operations: {
-        checked: (_) => _.apiResponseChecked,
-    },
+  Default: (_) => ({
+    apiResponseChecked: _ !== null && _ !== void 0 ? _ : false,
+  }),
+  Updaters: () => ({
+    toChecked: () => (_) =>
+      Object.assign(Object.assign({}, _), { apiResponseChecked: true }),
+    toUnchecked: () => (_) =>
+      Object.assign(Object.assign({}, _), { apiResponseChecked: false }),
+  }),
+  Operations: {
+    checked: (_) => _.apiResponseChecked,
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,5 +1,12 @@
-export declare const errorPermanenceStatus: readonly ["permanent failure", "transient failure"];
+export declare const errorPermanenceStatus: readonly [
+  "permanent failure",
+  "transient failure",
+];
 export type ErrorPermanenceStatus = (typeof errorPermanenceStatus)[number];
-export declare const apiResultStatuses: readonly ["success", "permanent failure", "transient failure"];
+export declare const apiResultStatuses: readonly [
+  "success",
+  "permanent failure",
+  "transient failure",
+];
 export type ApiResultStatus = (typeof apiResultStatuses)[number];
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/apiResultStatus/state.js

@@ -1,6 +1,3 @@
-export const errorPermanenceStatus = [
-    "permanent failure",
-    "transient failure",
-];
+export const errorPermanenceStatus = ["permanent failure", "transient failure"];
 export const apiResultStatuses = ["success", ...errorPermanenceStatus];
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/async/domains/mirroring/domains/collection/coroutines/synchronizers.d.ts

@@ -1,95 +1,420 @@
 import { OrderedMap } from "immutable";
-import { Value, Guid, BasicUpdater, Updater, Unit, DirtyStatus } from "../../../../../../../main";
+import {
+  Value,
+  Guid,
+  BasicUpdater,
+  Updater,
+  Unit,
+  DirtyStatus,
+} from "../../../../../../../main";
 import { Coroutine } from "../../../../../../coroutines/state";
 import { Fun, BasicFun } from "../../../../../../fun/state";
 import { Synchronized } from "../../../../synchronized/state";
 import { SynchronizationResult } from "../../synchronization-result/state";
 import { Collection, CollectionEntity } from "../state";
-export type CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations> = {
-    [k in keyof Collections & keyof CollectionMutations & keyof WholeCollectionMutations]: {
-        add: (entity: CollectionEntity<Collections[k]>, position?: InsertionPosition) => Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>;
-        remove: (entityId: Guid) => Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>;
-        wholeMutations: {
-            [_ in keyof WholeCollectionMutations[k]]: BasicFun<WholeCollectionMutations[k][_], Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>>;
-        };
-    } & {
-        [_ in keyof CollectionMutations[k]]: BasicFun<CollectionMutations[k][_], Coroutine<Context & CollectionEntity<Collections[k]>, CollectionEntity<Collections[k]>, SynchronizationResult>>;
+export type CollectionSynchronizers<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+> = {
+  [k in keyof Collections &
+    keyof CollectionMutations &
+    keyof WholeCollectionMutations]: {
+    add: (
+      entity: CollectionEntity<Collections[k]>,
+      position?: InsertionPosition,
+    ) => Coroutine<
+      Context & CollectionEntity<Collections[k]>,
+      CollectionEntity<Collections[k]>,
+      SynchronizationResult
+    >;
+    remove: (
+      entityId: Guid,
+    ) => Coroutine<
+      Context & CollectionEntity<Collections[k]>,
+      CollectionEntity<Collections[k]>,
+      SynchronizationResult
+    >;
+    wholeMutations: {
+      [_ in keyof WholeCollectionMutations[k]]: BasicFun<
+        WholeCollectionMutations[k][_],
+        Coroutine<
+          Context &
+            Synchronized<
+              Unit,
+              OrderedMap<Guid, CollectionEntity<Collections[k]>>
+            >,
+          Synchronized<
+            Unit,
+            OrderedMap<Guid, CollectionEntity<Collections[k]>>
+          >,
+          Unit
+        >
+      >;
     };
+  } & {
+    [_ in keyof CollectionMutations[k]]: BasicFun<
+      CollectionMutations[k][_],
+      Coroutine<
+        Context & CollectionEntity<Collections[k]>,
+        CollectionEntity<Collections[k]>,
+        SynchronizationResult
+      >
+    >;
+  };
 };
-export type CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
-    [k in keyof Collections & keyof CollectionMutations & keyof WholeCollectionMutations]: {
-        <mutation extends keyof CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>[k] & keyof CollectionMutations[k]>(mutation: mutation, mutationArg: CollectionMutations[k][mutation], entityId: Guid): Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
-        add: (entityId: Guid, entity: CollectionEntity<Collections[k]>, position?: InsertionPosition) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
-        remove: (entityId: Guid) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
-        wholeMutations: <mutation extends keyof CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>[k] & keyof WholeCollectionMutations[k]>(mutation: mutation, mutationArg: WholeCollectionMutations[k][mutation]) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
-    };
+export type CollectionLoaders<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+> = {
+  [k in keyof Collections &
+    keyof CollectionMutations &
+    keyof WholeCollectionMutations]: {
+    <
+      mutation extends keyof CollectionSynchronizers<
+        Context,
+        Collections,
+        CollectionMutations,
+        WholeCollectionMutations
+      >[k] &
+        keyof CollectionMutations[k],
+    >(
+      mutation: mutation,
+      mutationArg: CollectionMutations[k][mutation],
+      entityId: Guid,
+    ): Coroutine<
+      Context & SynchronizedEntities,
+      SynchronizedEntities,
+      SynchronizationResult
+    >;
+    add: (
+      entityId: Guid,
+      entity: CollectionEntity<Collections[k]>,
+      position?: InsertionPosition,
+    ) => Coroutine<
+      Context & SynchronizedEntities,
+      SynchronizedEntities,
+      SynchronizationResult
+    >;
+    remove: (
+      entityId: Guid,
+    ) => Coroutine<
+      Context & SynchronizedEntities,
+      SynchronizedEntities,
+      SynchronizationResult
+    >;
+    wholeMutations: <
+      mutation extends keyof CollectionSynchronizers<
+        Context,
+        Collections,
+        CollectionMutations,
+        WholeCollectionMutations
+      >[k] &
+        keyof WholeCollectionMutations[k],
+    >(
+      mutation: mutation,
+      mutationArg: WholeCollectionMutations[k][mutation],
+    ) => Coroutine<
+      Context & SynchronizedEntities,
+      SynchronizedEntities,
+      SynchronizationResult
+    >;
+  };
 };
-export declare const collectionEntityLoader: <Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>(synchronizers: CollectionSynchronizers<Context, Collections, CollectionMutations, WholeCollectionMutations>) => <k extends keyof Collections & keyof CollectionMutations & keyof WholeCollectionMutations>(k: k, id: BasicFun<Collections[k], Guid>, narrowing_k: BasicFun<SynchronizedEntities, Collection<Collections[k]>>, widening_k: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>, dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>) => CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>[k];
-export type CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
-    [k in keyof Collections & keyof CollectionMutations]: (entityId: Guid, dirtyStatus: DirtyStatus) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>;
+export declare const collectionEntityLoader: <
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+>(
+  synchronizers: CollectionSynchronizers<
+    Context,
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations
+  >,
+) => <
+  k extends keyof Collections &
+    keyof CollectionMutations &
+    keyof WholeCollectionMutations,
+>(
+  k: k,
+  id: BasicFun<Collections[k], Guid>,
+  narrowing_k: BasicFun<SynchronizedEntities, Collection<Collections[k]>>,
+  widening_k: BasicFun<
+    BasicUpdater<Collection<Collections[k]>>,
+    Updater<SynchronizedEntities>
+  >,
+  dependees: Array<
+    Coroutine<
+      Context & SynchronizedEntities,
+      SynchronizedEntities,
+      SynchronizationResult
+    >
+  >,
+) => CollectionLoaders<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities
+>[k];
+export type CollectionDirtySetters<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+> = {
+  [k in keyof Collections & keyof CollectionMutations]: (
+    entityId: Guid,
+    dirtyStatus: DirtyStatus,
+  ) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>;
 };
-export declare const collectionDirtySetter: <Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>() => <k extends keyof Collections & keyof CollectionMutations>(k: k, narrowing_k: BasicFun<SynchronizedEntities, Collection<Collections[k]>>, widening_k: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>) => CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>[k];
-export type CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations> = {
-    [k in keyof Collections & keyof CollectionMutations]: Fun<[
-        Guid,
-        Collection<Collections[k]>
-    ], boolean>;
+export declare const collectionDirtySetter: <
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+>() => <k extends keyof Collections & keyof CollectionMutations>(
+  k: k,
+  narrowing_k: BasicFun<SynchronizedEntities, Collection<Collections[k]>>,
+  widening_k: BasicFun<
+    BasicUpdater<Collection<Collections[k]>>,
+    Updater<SynchronizedEntities>
+  >,
+) => CollectionDirtySetters<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities
+>[k];
+export type CollectionDirtyCheckers<
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+> = {
+  [k in keyof Collections & keyof CollectionMutations]: Fun<
+    [Guid, Collection<Collections[k]>],
+    boolean
+  >;
 };
-export declare const collectionCheckNotDirty: <Collections, CollectionMutations, WholeCollectionMutations>() => <k extends keyof Collections & keyof CollectionMutations>([id, e]: [Guid, Collection<Collections[k]>]) => boolean;
-export type CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
-    [k in keyof Collections & keyof CollectionMutations]: Fun<[
-        Guid,
-        BasicUpdater<Collections[k]>
-    ], Updater<SynchronizedEntities>>;
+export declare const collectionCheckNotDirty: <
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+>() => <k extends keyof Collections & keyof CollectionMutations>([id, e]: [
+  Guid,
+  Collection<Collections[k]>,
+]) => boolean;
+export type CollectionUpdaters<
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+> = {
+  [k in keyof Collections & keyof CollectionMutations]: Fun<
+    [Guid, BasicUpdater<Collections[k]>],
+    Updater<SynchronizedEntities>
+  >;
 };
-export declare const collectionEntityUpdater: <Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>() => <k extends keyof Collections & keyof CollectionMutations>(widening_k: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>) => Fun<[Guid, BasicUpdater<Collections[k]>], Updater<SynchronizedEntities>>;
-export type CollectionMutationArgumentComparators<Collections, CollectionMutations> = {
-    [k in keyof Collections & keyof CollectionMutations]: {
-        [_ in keyof CollectionMutations[k]]: MutationArgumentComparator<CollectionMutations[k][_]>;
-    };
-};
-export type WholeCollectionMutationArgumentComparators<Collections, WholeCollectionMutations> = {
-    [k in keyof Collections & keyof WholeCollectionMutations]: {
-        [_ in keyof WholeCollectionMutations[k]]: MutationArgumentComparator<WholeCollectionMutations[k][_]>;
-    };
+export declare const collectionEntityUpdater: <
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+>() => <k extends keyof Collections & keyof CollectionMutations>(
+  widening_k: BasicFun<
+    BasicUpdater<Collection<Collections[k]>>,
+    Updater<SynchronizedEntities>
+  >,
+) => Fun<[Guid, BasicUpdater<Collections[k]>], Updater<SynchronizedEntities>>;
+export type CollectionMutationArgumentComparators<
+  Collections,
+  CollectionMutations,
+> = {
+  [k in keyof Collections & keyof CollectionMutations]: {
+    [_ in keyof CollectionMutations[k]]: MutationArgumentComparator<
+      CollectionMutations[k][_]
+    >;
+  };
 };
-export type InsertionPosition = {
-    kind: "after";
-    id: Guid;
-} | {
-    kind: "before";
-    id: Guid;
-} | {
-    kind: "at the end";
-} | {
-    kind: "at the beginning";
+export type WholeCollectionMutationArgumentComparators<
+  Collections,
+  WholeCollectionMutations,
+> = {
+  [k in keyof Collections & keyof WholeCollectionMutations]: {
+    [_ in keyof WholeCollectionMutations[k]]: MutationArgumentComparator<
+      WholeCollectionMutations[k][_]
+    >;
+  };
 };
+export type InsertionPosition =
+  | {
+      kind: "after";
+      id: Guid;
+    }
+  | {
+      kind: "before";
+      id: Guid;
+    }
+  | {
+      kind: "at the end";
+    }
+  | {
+      kind: "at the beginning";
+    };
 export type ComparisonResult = ">" | "<" | "==";
 export type MutationArgumentComparator<T> = BasicFun<[T, T], ComparisonResult>;
-export declare const withTrivialComparator: <f, ma>(_: f) => [f, MutationArgumentComparator<ma>];
-export type SynchronizableCollectionEntity<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities, k extends keyof Collections & keyof CollectionMutations & keyof WholeCollectionMutations> = {
-    entityName: k;
-    id: BasicFun<Collections[k], Guid>;
-    narrowing: BasicFun<SynchronizedEntities, Collection<Collections[k]>>;
-    widening: BasicFun<BasicUpdater<Collection<Collections[k]>>, Updater<SynchronizedEntities>>;
-    dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>;
-    add: (entity: CollectionEntity<Collections[k]>, position?: InsertionPosition) => Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>;
-    remove: (entityId: Guid) => Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>;
+export declare const withTrivialComparator: <f, ma>(
+  _: f,
+) => [f, MutationArgumentComparator<ma>];
+export type SynchronizableCollectionEntity<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+  k extends keyof Collections &
+    keyof CollectionMutations &
+    keyof WholeCollectionMutations,
+> = {
+  entityName: k;
+  id: BasicFun<Collections[k], Guid>;
+  narrowing: BasicFun<SynchronizedEntities, Collection<Collections[k]>>;
+  widening: BasicFun<
+    BasicUpdater<Collection<Collections[k]>>,
+    Updater<SynchronizedEntities>
+  >;
+  dependees: Array<
+    Coroutine<
+      Context & SynchronizedEntities,
+      SynchronizedEntities,
+      SynchronizationResult
+    >
+  >;
+  add: (
+    entity: CollectionEntity<Collections[k]>,
+    position?: InsertionPosition,
+  ) => Coroutine<
+    Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>,
+    Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>,
+    Unit
+  >;
+  remove: (
+    entityId: Guid,
+  ) => Coroutine<
+    Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>,
+    Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>,
+    Unit
+  >;
 } & {
-    [_ in keyof CollectionMutations[k]]: [
-        BasicFun<CollectionMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>, Unit>>,
-        MutationArgumentComparator<CollectionMutations[k][_]>
-    ];
+  [_ in keyof CollectionMutations[k]]: [
+    BasicFun<
+      CollectionMutations[k][_],
+      Coroutine<
+        Context & Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>,
+        Synchronized<Value<Synchronized<Unit, Collections[k]>>, Unit>,
+        Unit
+      >
+    >,
+    MutationArgumentComparator<CollectionMutations[k][_]>,
+  ];
 } & {
-    wholeMutations: {
-        [_ in keyof WholeCollectionMutations[k]]: [
-            BasicFun<WholeCollectionMutations[k][_], Coroutine<Context & Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Synchronized<Unit, OrderedMap<Guid, CollectionEntity<Collections[k]>>>, Unit>>,
-            MutationArgumentComparator<WholeCollectionMutations[k][_]>
-        ];
-    };
+  wholeMutations: {
+    [_ in keyof WholeCollectionMutations[k]]: [
+      BasicFun<
+        WholeCollectionMutations[k][_],
+        Coroutine<
+          Context &
+            Synchronized<
+              Unit,
+              OrderedMap<Guid, CollectionEntity<Collections[k]>>
+            >,
+          Synchronized<
+            Unit,
+            OrderedMap<Guid, CollectionEntity<Collections[k]>>
+          >,
+          Unit
+        >
+      >,
+      MutationArgumentComparator<WholeCollectionMutations[k][_]>,
+    ];
+  };
 };
-export type SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities> = {
-    [k in keyof Collections & keyof CollectionMutations & keyof WholeCollectionMutations]: SynchronizableCollectionEntity<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities, k>;
+export type SynchronizableEntityDescriptor<
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+> = {
+  [k in keyof Collections &
+    keyof CollectionMutations &
+    keyof WholeCollectionMutations]: SynchronizableCollectionEntity<
+    Context,
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations,
+    SynchronizedEntities,
+    k
+  >;
 };
-export declare const collectionSynchronizationContext: <Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>(entityDescriptors: SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>) => [CollectionLoaders<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>, CollectionDirtyCheckers<Collections, CollectionMutations, WholeCollectionMutations>, CollectionDirtySetters<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>, CollectionUpdaters<Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>, SynchronizableEntityDescriptor<Context, Collections, CollectionMutations, WholeCollectionMutations, SynchronizedEntities>, CollectionMutationArgumentComparators<Collections, CollectionMutations>, CollectionMutationArgumentComparators<Collections, WholeCollectionMutations>];
-//# sourceMappingURL=synchronizers.d.ts.map
+export declare const collectionSynchronizationContext: <
+  Context,
+  Collections,
+  CollectionMutations,
+  WholeCollectionMutations,
+  SynchronizedEntities,
+>(
+  entityDescriptors: SynchronizableEntityDescriptor<
+    Context,
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations,
+    SynchronizedEntities
+  >,
+) => [
+  CollectionLoaders<
+    Context,
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations,
+    SynchronizedEntities
+  >,
+  CollectionDirtyCheckers<
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations
+  >,
+  CollectionDirtySetters<
+    Context,
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations,
+    SynchronizedEntities
+  >,
+  CollectionUpdaters<
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations,
+    SynchronizedEntities
+  >,
+  SynchronizableEntityDescriptor<
+    Context,
+    Collections,
+    CollectionMutations,
+    WholeCollectionMutations,
+    SynchronizedEntities
+  >,
+  CollectionMutationArgumentComparators<Collections, CollectionMutations>,
+  CollectionMutationArgumentComparators<Collections, WholeCollectionMutations>,
+];
+//# sourceMappingURL=synchronizers.d.ts.map