ballerina-core 1.0.252 → 1.0.253

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,11 +1,4 @@
 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,24 +1,17 @@
 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,15 +1,13 @@
 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,12 +1,5 @@
-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,3 +1,6 @@
-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,420 +1,95 @@
 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
-        >
-      >;
+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>>;
     };
-  } & {
-    [_ 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 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 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 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 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 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 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 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 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 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
-  >;
-} & {
-  [_ 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][_]>,
-  ];
+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>;
 } & {
-  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][_]>,
+    [_ 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][_]>
+        ];
+    };
 };
-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