ballerina-core 1.0.243 → 1.0.244

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

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

@@ -1,50 +1,37 @@
-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">;
+    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>>;
+        };
     };
-    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,17 +1,13 @@
 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