ballerina-core 1.0.220 → 1.0.222

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/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/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/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

package/bin/src/async/domains/mirroring/domains/collection/state.d.ts

@@ -1,37 +1,50 @@
-import { BasicUpdater, Guid, Synchronized, Updater, Unit, InsertionPosition } from "ballerina-core";
+import {
+  BasicUpdater,
+  Guid,
+  Synchronized,
+  Updater,
+  Unit,
+  InsertionPosition,
+} from "ballerina-core";
 import { OrderedMap } from "immutable";
 import { Entity } from "../entity/state";
 export type CollectionEntity<E> = Entity<E> & {
-    removed: boolean;
+  removed: boolean;
 };
 export declare const CollectionEntity: <E>() => {
-    Default: (value: E) => CollectionEntity<E>;
-    Updaters: {
-        Core: {
-            entity: (_: BasicUpdater<Entity<E>>) => Updater<CollectionEntity<E>>;
-            removed: (_: BasicUpdater<boolean>) => Updater<CollectionEntity<E>>;
-        };
+  Default: (value: E) => CollectionEntity<E>;
+  Updaters: {
+    Core: {
+      entity: (_: BasicUpdater<Entity<E>>) => Updater<CollectionEntity<E>>;
+      removed: (_: BasicUpdater<boolean>) => Updater<CollectionEntity<E>>;
     };
+  };
 };
 export type Collection<E> = {
-    entities: Synchronized<Unit, OrderedMap<Guid, CollectionEntity<E>>>;
+  entities: Synchronized<Unit, OrderedMap<Guid, CollectionEntity<E>>>;
 };
 export declare const Collection: <E>() => {
-    Default: (entities: OrderedMap<Guid, CollectionEntity<E>>) => Collection<E>;
-    Updaters: {
-        Core: {
-            entity: {
-                add: ([id, value, position]: [Guid, CollectionEntity<E>, InsertionPosition]) => Updater<Collection<E>>;
-                remove: (id: Guid) => Updater<Collection<E>>;
-                set: (id: Guid) => (u: BasicUpdater<CollectionEntity<E>>) => Updater<Collection<E>>;
-            };
-            removed: (id: Guid, u: BasicUpdater<boolean>) => Updater<Collection<E>>;
-            entityValue: (id: Guid, u: BasicUpdater<E>) => Updater<Collection<E>>;
-            entities: import("ballerina-core").Widening<Collection<E>, "entities">;
-        };
-        Template: {
-            entityValue: (id: Guid, u: BasicUpdater<E>) => Updater<Collection<E>>;
-        };
+  Default: (entities: OrderedMap<Guid, CollectionEntity<E>>) => Collection<E>;
+  Updaters: {
+    Core: {
+      entity: {
+        add: ([id, value, position]: [
+          Guid,
+          CollectionEntity<E>,
+          InsertionPosition,
+        ]) => Updater<Collection<E>>;
+        remove: (id: Guid) => Updater<Collection<E>>;
+        set: (
+          id: Guid,
+        ) => (u: BasicUpdater<CollectionEntity<E>>) => Updater<Collection<E>>;
+      };
+      removed: (id: Guid, u: BasicUpdater<boolean>) => Updater<Collection<E>>;
+      entityValue: (id: Guid, u: BasicUpdater<E>) => Updater<Collection<E>>;
+      entities: import("ballerina-core").Widening<Collection<E>, "entities">;
     };
+    Template: {
+      entityValue: (id: Guid, u: BasicUpdater<E>) => Updater<Collection<E>>;
+    };
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/mirroring/domains/entity/domains/loaded-collection/state.d.ts

@@ -1,13 +1,17 @@
 import { OrderedMap } from "immutable";
-import { Collection, Guid, LoadedCollectionEntity } from "../../../../../../../../main";
+import {
+  Collection,
+  Guid,
+  LoadedCollectionEntity,
+} from "../../../../../../../../main";
 export type LoadedCollection<E> = {
-    values?: OrderedMap<Guid, LoadedCollectionEntity<E>>;
-    isReloading: boolean;
-    synchronizationErrors: Array<any>;
+  values?: OrderedMap<Guid, LoadedCollectionEntity<E>>;
+  isReloading: boolean;
+  synchronizationErrors: Array<any>;
 };
 export declare const LoadedCollection: {
-    Default: {
-        fromCollection: <E>(collection: Collection<E>) => LoadedCollection<E>;
-    };
+  Default: {
+    fromCollection: <E>(collection: Collection<E>) => LoadedCollection<E>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map