ballerina-core 1.0.218 → 1.0.220

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

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

@@ -1,19 +1,16 @@
 import { Sum } from "../../../../../../../../main";
-import {
-  DebouncedStatus,
-  DirtyStatus,
-} from "../../../../../../../debounced/state";
+import { DebouncedStatus, DirtyStatus } from "../../../../../../../debounced/state";
 import { CollectionEntity } from "../../../collection/state";
 import { LoadedEntity } from "../loaded-entity/state";
 export type LoadedCollectionEntity<E> = LoadedEntity<E> & {
-  isRemoved: boolean;
-  lastUpdated: number;
-  dirty: DirtyStatus;
-  status: Sum<DebouncedStatus, "debug off">;
+    isRemoved: boolean;
+    lastUpdated: number;
+    dirty: DirtyStatus;
+    status: Sum<DebouncedStatus, "debug off">;
 };
 export declare const LoadedCollectionEntity: {
-  Default: {
-    fromEntity: <E>(e: CollectionEntity<E>) => LoadedCollectionEntity<E>;
-  };
+    Default: {
+        fromEntity: <E>(e: CollectionEntity<E>) => LoadedCollectionEntity<E>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,20 +1,11 @@
 import { LoadedCollection } from "../../../../../../../../main";
 import { LoadedEntity } from "../loaded-entity/state";
-export type LoadedEntities<
-  Singletons,
-  Collections,
-  SingletonMutations,
-  CollectionMutations,
-> = {
-  singletons: {
-    [k in keyof Singletons & keyof SingletonMutations]: LoadedEntity<
-      Singletons[k]
-    >;
-  };
-  collections: {
-    [k in keyof Collections & keyof CollectionMutations]: LoadedCollection<
-      Collections[k]
-    >;
-  };
+export type LoadedEntities<Singletons, Collections, SingletonMutations, CollectionMutations> = {
+    singletons: {
+        [k in keyof Singletons & keyof SingletonMutations]: LoadedEntity<Singletons[k]>;
+    };
+    collections: {
+        [k in keyof Collections & keyof CollectionMutations]: LoadedCollection<Collections[k]>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,22 +1,19 @@
 import { Sum } from "../../../../../../../../main";
-import {
-  DebouncedStatus,
-  DirtyStatus,
-} from "../../../../../../../debounced/state";
+import { DebouncedStatus, DirtyStatus } from "../../../../../../../debounced/state";
 import { Entity } from "../../state";
 export type LoadedEntity<E> = {
-  value?: E;
-  isSubmitting: boolean;
-  isReloading: boolean;
-  isBeingCreated: boolean;
-  synchronizationErrors: Array<any>;
-  lastUpdated: number;
-  dirty: DirtyStatus;
-  status: Sum<DebouncedStatus, "debug off">;
+    value?: E;
+    isSubmitting: boolean;
+    isReloading: boolean;
+    isBeingCreated: boolean;
+    synchronizationErrors: Array<any>;
+    lastUpdated: number;
+    dirty: DirtyStatus;
+    status: Sum<DebouncedStatus, "debug off">;
 };
 export declare const LoadedEntity: {
-  Default: {
-    fromEntity: <E>(e: Entity<E>) => LoadedEntity<E>;
-  };
+    Default: {
+        fromEntity: <E>(e: Entity<E>) => LoadedEntity<E>;
+    };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -2,19 +2,16 @@ import { Debounced, Value } from "ballerina-core";
 import { Synchronized } from "ballerina-core";
 import { Unit } from "ballerina-core";
 export type Entity<E> = {
-  value: Debounced<Synchronized<Value<Synchronized<Unit, E>>, Unit>>;
-  isBeingCreated: boolean;
+    value: Debounced<Synchronized<Value<Synchronized<Unit, E>>, Unit>>;
+    isBeingCreated: boolean;
 };
 export declare const Entity: <E>() => {
-  Default: (value: E) => Entity<E>;
-  Updaters: {
-    Core: {
-      isBeingCreated: import("ballerina-core").Widening<
-        Entity<E>,
-        "isBeingCreated"
-      >;
-      value: import("ballerina-core").Widening<Entity<E>, "value">;
+    Default: (value: E) => Entity<E>;
+    Updaters: {
+        Core: {
+            isBeingCreated: import("ballerina-core").Widening<Entity<E>, "isBeingCreated">;
+            value: import("ballerina-core").Widening<Entity<E>, "value">;
+        };
     };
-  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,10 +1,4 @@
-import {
-  Unit,
-  BasicUpdater,
-  Updater,
-  Value,
-  MutationArgumentComparator,
-} from "../../../../../../../main";
+import { Unit, BasicUpdater, Updater, Value, MutationArgumentComparator } from "../../../../../../../main";
 import { Coroutine } from "../../../../../../coroutines/state";
 import { DirtyStatus } from "../../../../../../debounced/state";
 import { Fun, BasicFun } from "../../../../../../fun/state";
@@ -13,237 +7,51 @@ import { Entity } from "../../entity/state";
 import { SynchronizationResult } from "../../synchronization-result/state";
 import { Singleton } from "../state";
 export type SingletonSynchronizers<Context, Singletons, SingletonMutations> = {
-  [k in keyof Singletons & keyof SingletonMutations]: {
-    [_ in keyof SingletonMutations[k]]: BasicFun<
-      SingletonMutations[k][_],
-      Coroutine<
-        Context & Entity<Singletons[k]>,
-        Entity<Singletons[k]>,
-        SynchronizationResult
-      >
-    >;
-  };
+    [k in keyof Singletons & keyof SingletonMutations]: {
+        [_ in keyof SingletonMutations[k]]: BasicFun<SingletonMutations[k][_], Coroutine<Context & Entity<Singletons[k]>, Entity<Singletons[k]>, SynchronizationResult>>;
+    };
 };
-export declare const insideEntitySynchronizedAndDebounced: <Context, E>(
-  k: Coroutine<
-    Context & Synchronized<Value<Synchronized<Unit, E>>, Unit>,
-    Synchronized<Value<Synchronized<Unit, E>>, Unit>,
-    Unit
-  >,
-) => Coroutine<Context & Entity<E>, Entity<E>, SynchronizationResult>;
-export type SingletonLoaders<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons & keyof SingletonMutations]: <
-    mutation extends keyof SingletonSynchronizers<
-      Context,
-      Singletons,
-      SingletonMutations
-    >[k] &
-      keyof SingletonMutations[k],
-  >(
-    mutation: mutation,
-    mutationArg: SingletonMutations[k][mutation],
-  ) => Coroutine<
-    Context & SynchronizedEntities,
-    SynchronizedEntities,
-    SynchronizationResult
-  >;
+export declare const insideEntitySynchronizedAndDebounced: <Context, E>(k: Coroutine<Context & Synchronized<Value<Synchronized<Unit, E>>, Unit>, Synchronized<Value<Synchronized<Unit, E>>, Unit>, Unit>) => Coroutine<Context & Entity<E>, Entity<E>, SynchronizationResult>;
+export type SingletonLoaders<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: <mutation extends keyof SingletonSynchronizers<Context, Singletons, SingletonMutations>[k] & keyof SingletonMutations[k]>(mutation: mutation, mutationArg: SingletonMutations[k][mutation]) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
 };
-export type SingletonMutationArgumentComparators<
-  Singletons,
-  SingletonMutation,
-> = {
-  [k in keyof Singletons & keyof SingletonMutation]: {
-    [_ in keyof SingletonMutation[k]]: MutationArgumentComparator<
-      SingletonMutation[k][_]
-    >;
-  };
+export type SingletonMutationArgumentComparators<Singletons, SingletonMutation> = {
+    [k in keyof Singletons & keyof SingletonMutation]: {
+        [_ in keyof SingletonMutation[k]]: MutationArgumentComparator<SingletonMutation[k][_]>;
+    };
 };
-export declare const singletonEntityLoader: <
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->(
-  synchronizers: SingletonSynchronizers<
-    Context,
-    Singletons,
-    SingletonMutations
-  >,
-) => <k extends keyof Singletons & keyof SingletonMutations>(
-  k: k,
-  narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>,
-  widening_k: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >,
-  dependees: Array<
-    Coroutine<
-      Context & SynchronizedEntities,
-      SynchronizedEntities,
-      SynchronizationResult
-    >
-  >,
-) => <
-  mutation extends keyof SingletonSynchronizers<
-    Context,
-    Singletons,
-    SingletonMutations
-  >[k] &
-    keyof SingletonMutations[k],
->(
-  mutation: mutation,
-  mutationArg: SingletonMutations[k][mutation],
-) => Coroutine<
-  Context & SynchronizedEntities,
-  SynchronizedEntities,
-  SynchronizationResult
->;
-export type SingletonDirtySetters<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons & keyof SingletonMutations]: BasicFun<
-    DirtyStatus,
-    Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>
-  >;
+export declare const singletonEntityLoader: <Context, Singletons, SingletonMutations, SynchronizedEntities>(synchronizers: SingletonSynchronizers<Context, Singletons, SingletonMutations>) => <k extends keyof Singletons & keyof SingletonMutations>(k: k, narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>, widening_k: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>, dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>) => <mutation extends keyof SingletonSynchronizers<Context, Singletons, SingletonMutations>[k] & keyof SingletonMutations[k]>(mutation: mutation, mutationArg: SingletonMutations[k][mutation]) => Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>;
+export type SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: BasicFun<DirtyStatus, Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>>;
 };
-export declare const singletonDirtySetter: <
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->() => <k extends keyof Singletons & keyof SingletonMutations>(
-  k: k,
-  narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>,
-  widening_k: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >,
-) => BasicFun<
-  DirtyStatus,
-  Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>
->;
+export declare const singletonDirtySetter: <Context, Singletons, SingletonMutations, SynchronizedEntities>() => <k extends keyof Singletons & keyof SingletonMutations>(k: k, narrowing_k: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>, widening_k: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>) => BasicFun<DirtyStatus, Coroutine<Context & SynchronizedEntities, SynchronizedEntities, Unit>>;
 export type SingletonDirtyCheckers<Singletons, SingletonMutations> = {
-  [k in keyof Singletons & keyof SingletonMutations]: Fun<
-    [Unit, Singleton<Singletons[k]>],
-    boolean
-  >;
-};
-export declare const singletonCheckNotDirty: <
-  Singletons,
-  SingletonMutations,
->() => <k extends keyof Singletons & keyof SingletonMutations>([_, e]: [
-  Unit,
-  Singleton<Singletons[k]>,
-]) => boolean;
-export type SingletonUpdaters<
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons & keyof SingletonMutations]: Fun<
-    [Unit, BasicUpdater<Singletons[k]>],
-    Updater<SynchronizedEntities>
-  >;
-};
-export declare const singletonEntityUpdater: <
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->() => <k extends keyof Singletons & keyof SingletonMutations>(
-  widening_k: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >,
-) => Fun<[Unit, BasicUpdater<Singletons[k]>], Updater<SynchronizedEntities>>;
-export type SynchronizableSingletonEntity<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-  k extends keyof Singletons & keyof SingletonMutations,
-> = {
-  entityName: k;
-  narrowing: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>;
-  widening: BasicFun<
-    BasicUpdater<Singleton<Singletons[k]>>,
-    Updater<SynchronizedEntities>
-  >;
-  dependees: Array<
-    Coroutine<
-      Context & SynchronizedEntities,
-      SynchronizedEntities,
-      SynchronizationResult
-    >
-  >;
+    [k in keyof Singletons & keyof SingletonMutations]: Fun<[
+        Unit,
+        Singleton<Singletons[k]>
+    ], boolean>;
+};
+export declare const singletonCheckNotDirty: <Singletons, SingletonMutations>() => <k extends keyof Singletons & keyof SingletonMutations>([_, e]: [Unit, Singleton<Singletons[k]>]) => boolean;
+export type SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: Fun<[
+        Unit,
+        BasicUpdater<Singletons[k]>
+    ], Updater<SynchronizedEntities>>;
+};
+export declare const singletonEntityUpdater: <Singletons, SingletonMutations, SynchronizedEntities>() => <k extends keyof Singletons & keyof SingletonMutations>(widening_k: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>) => Fun<[Unit, BasicUpdater<Singletons[k]>], Updater<SynchronizedEntities>>;
+export type SynchronizableSingletonEntity<Context, Singletons, SingletonMutations, SynchronizedEntities, k extends keyof Singletons & keyof SingletonMutations> = {
+    entityName: k;
+    narrowing: BasicFun<SynchronizedEntities, Singleton<Singletons[k]>>;
+    widening: BasicFun<BasicUpdater<Singleton<Singletons[k]>>, Updater<SynchronizedEntities>>;
+    dependees: Array<Coroutine<Context & SynchronizedEntities, SynchronizedEntities, SynchronizationResult>>;
 } & {
-  [_ in keyof SingletonMutations[k]]: [
-    BasicFun<
-      SingletonMutations[k][_],
-      Coroutine<
-        Context & Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>,
-        Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>,
-        Unit
-      >
-    >,
-    MutationArgumentComparator<SingletonMutations[k][_]>,
-  ];
+    [_ in keyof SingletonMutations[k]]: [
+        BasicFun<SingletonMutations[k][_], Coroutine<Context & Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Synchronized<Value<Synchronized<Unit, Singletons[k]>>, Unit>, Unit>>,
+        MutationArgumentComparator<SingletonMutations[k][_]>
+    ];
 };
-export type SynchronizableEntityDescriptors<
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
-> = {
-  [k in keyof Singletons &
-    keyof SingletonMutations]: SynchronizableSingletonEntity<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities,
-    k
-  >;
+export type SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities> = {
+    [k in keyof Singletons & keyof SingletonMutations]: SynchronizableSingletonEntity<Context, Singletons, SingletonMutations, SynchronizedEntities, k>;
 };
-export declare const singletonSynchronizationContext: <
-  Context,
-  Singletons,
-  SingletonMutations,
-  SynchronizedEntities,
->(
-  entityDescriptors: SynchronizableEntityDescriptors<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-) => [
-  SingletonLoaders<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-  SingletonDirtyCheckers<Singletons, SingletonMutations>,
-  SingletonDirtySetters<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-  SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities>,
-  SynchronizableEntityDescriptors<
-    Context,
-    Singletons,
-    SingletonMutations,
-    SynchronizedEntities
-  >,
-  SingletonMutationArgumentComparators<Singletons, SingletonMutations>,
-];
-//# sourceMappingURL=synchronizers.d.ts.map
+export declare const singletonSynchronizationContext: <Context, Singletons, SingletonMutations, SynchronizedEntities>(entityDescriptors: SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities>) => [SingletonLoaders<Context, Singletons, SingletonMutations, SynchronizedEntities>, SingletonDirtyCheckers<Singletons, SingletonMutations>, SingletonDirtySetters<Context, Singletons, SingletonMutations, SynchronizedEntities>, SingletonUpdaters<Singletons, SingletonMutations, SynchronizedEntities>, SynchronizableEntityDescriptors<Context, Singletons, SingletonMutations, SynchronizedEntities>, SingletonMutationArgumentComparators<Singletons, SingletonMutations>];
+//# sourceMappingURL=synchronizers.d.ts.map

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

@@ -1,31 +1,22 @@
 import { BasicUpdater, Synchronized, Unit, Updater } from "ballerina-core";
 import { Entity } from "../entity/state";
 export type Singleton<E> = {
-  entity: Entity<E>;
+    entity: Entity<E>;
 };
 export declare const Singleton: <E>() => {
-  Default: (entity: Entity<E>) => Singleton<E>;
-  Updaters: {
-    Core: {
-      reloader: (
-        u: BasicUpdater<Synchronized<Unit, E>>,
-      ) => Updater<Singleton<E>>;
-      entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
-      entity: import("ballerina-core").WideningWithChildren<
-        Singleton<E>,
-        "entity",
-        {
-          isBeingCreated: import("ballerina-core").Widening<
-            Entity<E>,
-            "isBeingCreated"
-          >;
-          value: import("ballerina-core").Widening<Entity<E>, "value">;
-        }
-      >;
+    Default: (entity: Entity<E>) => Singleton<E>;
+    Updaters: {
+        Core: {
+            reloader: (u: BasicUpdater<Synchronized<Unit, E>>) => Updater<Singleton<E>>;
+            entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
+            entity: import("ballerina-core").WideningWithChildren<Singleton<E>, "entity", {
+                isBeingCreated: import("ballerina-core").Widening<Entity<E>, "isBeingCreated">;
+                value: import("ballerina-core").Widening<Entity<E>, "value">;
+            }>;
+        };
+        Template: {
+            entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
+        };
     };
-    Template: {
-      entityValue: (u: BasicUpdater<E>) => Updater<Singleton<E>>;
-    };
-  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/mirroring/domains/synchronization-result/state.d.ts

@@ -1,2 +1,5 @@
-export type SynchronizationResult = "completed" | "should be enqueued again";
+export type SynchronizationResult =
+  | "completed"
+  | "should be enqueued again"
+  | "permanent error";
 //# sourceMappingURL=state.d.ts.map

package/bin/src/async/domains/mirroring/domains/synchronization-result/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../src/async/domains/mirroring/domains/synchronization-result/state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG,WAAW,GAAG,0BAA0B,CAAC"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../../../../src/async/domains/mirroring/domains/synchronization-result/state.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAC7B,WAAW,GACX,0BAA0B,GAC1B,iBAAiB,CAAC"}

package/bin/src/async/domains/mirroring/domains/synchronized-entities/state.d.ts

@@ -1,26 +1,20 @@
 import { Singleton, Collection } from "ballerina-core";
 export type InsideSingletons<Entities> = {
-  [e_k in keyof Entities]: Singleton<Entities[e_k]>;
+    [e_k in keyof Entities]: Singleton<Entities[e_k]>;
 };
 export type InsideCollections<Entities> = {
-  [e_k in keyof Entities]: Collection<Entities[e_k]>;
+    [e_k in keyof Entities]: Collection<Entities[e_k]>;
 };
 export type SynchronizedEntities<Singletons, Collections> = {
-  singletons: InsideSingletons<Singletons>;
-  collections: InsideCollections<Collections>;
+    singletons: InsideSingletons<Singletons>;
+    collections: InsideCollections<Collections>;
 };
 export declare const SynchronizedEntities: <Singletons, Collections>() => {
-  Updaters: {
-    Core: {
-      collections: import("ballerina-core").Widening<
-        SynchronizedEntities<Singletons, Collections>,
-        "collections"
-      >;
-      singletons: import("ballerina-core").Widening<
-        SynchronizedEntities<Singletons, Collections>,
-        "singletons"
-      >;
+    Updaters: {
+        Core: {
+            collections: import("ballerina-core").Widening<SynchronizedEntities<Singletons, Collections>, "collections">;
+            singletons: import("ballerina-core").Widening<SynchronizedEntities<Singletons, Collections>, "singletons">;
+        };
     };
-  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map