ballerina-core 1.0.220 → 1.0.222

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

@@ -1,16 +1,19 @@
 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,11 +1,20 @@
 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,19 +1,22 @@
 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,16 +2,19 @@ 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,4 +1,10 @@
-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";
@@ -7,51 +13,237 @@ 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,22 +1,31 @@
 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">;
-            }>;
-        };
-        Template: {
-            entityValue: (u: BasicUpdater<E>) => Updater<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">;
+        }
+      >;
     };
+    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/synchronized-entities/state.d.ts

@@ -1,20 +1,26 @@
 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

package/bin/src/async/domains/synchronized/coroutines/synchronize.d.ts

@@ -1,9 +1,34 @@
 import { BasicUpdater } from "../../../../../main";
-import { ApiResultStatus, ErrorPermanenceStatus } from "../../../../apiResultStatus/state";
+import {
+  ApiResultStatus,
+  ErrorPermanenceStatus,
+} from "../../../../apiResultStatus/state";
 import { Coroutine } from "../../../../coroutines/state";
 import { Unit } from "../../../../fun/domains/unit/state";
 import { BasicFun } from "../../../../fun/state";
 import { Synchronized } from "../state";
-export declare const Synchronize: <value, syncResult, context = Unit>(p: BasicFun<value & context, Promise<syncResult>>, errorProcessor?: BasicFun<any, ErrorPermanenceStatus>, maxAttempts?: number, delayBetweenAttemptsInMs?: number) => Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus>;
-export declare const SynchronizeWithValueUpdater: <value, syncResult, context = Unit>(p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>, errorProcessor?: BasicFun<any, ErrorPermanenceStatus>, maxAttempts?: number, delayBetweenAttemptsInMs?: number) => Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus>;
-//# sourceMappingURL=synchronize.d.ts.map
+export declare const Synchronize: <value, syncResult, context = Unit>(
+  p: BasicFun<value & context, Promise<syncResult>>,
+  errorProcessor?: BasicFun<any, ErrorPermanenceStatus>,
+  maxAttempts?: number,
+  delayBetweenAttemptsInMs?: number,
+) => Coroutine<
+  Synchronized<value, syncResult> & context,
+  Synchronized<value, syncResult>,
+  ApiResultStatus
+>;
+export declare const SynchronizeWithValueUpdater: <
+  value,
+  syncResult,
+  context = Unit,
+>(
+  p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>,
+  errorProcessor?: BasicFun<any, ErrorPermanenceStatus>,
+  maxAttempts?: number,
+  delayBetweenAttemptsInMs?: number,
+) => Coroutine<
+  Synchronized<value, syncResult> & context,
+  Synchronized<value, syncResult>,
+  ApiResultStatus
+>;
+//# sourceMappingURL=synchronize.d.ts.map

package/bin/src/collections/domains/immutable/domains/list/state.d.ts

@@ -4,19 +4,23 @@ import { BasicFun } from "../../../../../fun/state";
 import { Option } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export declare const ListRepo: {
-    Default: {};
-    Updaters: {
-        remove<V>(elementIndex: number): Updater<List<V>>;
-        push<V>(v: V): Updater<List<V>>;
-        insert<V>(elementIndex: number, v: V): Updater<List<V>>;
-        update<V>(elementIndex: number, upd: Updater<V>): Updater<List<V>>;
-        filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>>;
-        move<V>(elementIndex: number, to: number): Updater<List<V>>;
-        duplicate<V>(elementIndex: number): Updater<List<V>>;
-    };
-    Operations: {
-        tryFind: <V>(elementIndex: number, list: List<V>) => Option<V>;
-        tryFindWithError: <v, e>(i: number, m: List<v>, e: () => e) => ValueOrErrors<v, e>;
-    };
+  Default: {};
+  Updaters: {
+    remove<V>(elementIndex: number): Updater<List<V>>;
+    push<V>(v: V): Updater<List<V>>;
+    insert<V>(elementIndex: number, v: V): Updater<List<V>>;
+    update<V>(elementIndex: number, upd: Updater<V>): Updater<List<V>>;
+    filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>>;
+    move<V>(elementIndex: number, to: number): Updater<List<V>>;
+    duplicate<V>(elementIndex: number): Updater<List<V>>;
+  };
+  Operations: {
+    tryFind: <V>(elementIndex: number, list: List<V>) => Option<V>;
+    tryFindWithError: <v, e>(
+      i: number,
+      m: List<v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/map/state.d.ts

@@ -1,24 +1,38 @@
 import { Map } from "immutable";
 import { Identifiable } from "../../../../../baseEntity/domains/identifiable/state";
 import { Unit } from "../../../../../fun/domains/unit/state";
-import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import {
+  BasicUpdater,
+  Updater,
+} from "../../../../../fun/domains/updater/state";
 import { BasicFun } from "../../../../../fun/state";
 import { Option } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export declare const MapRepo: {
-    Default: {
-        fromIdentifiables: <T extends Identifiable>(array: T[]) => Map<T["Id"], T>;
-    };
-    Updaters: {
-        set<K, V>(key: K, value: V): Updater<Map<K, V>>;
-        remove<K, V>(key: K): Updater<Map<K, V>>;
-        update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<Map<k, v>>;
-        upsert: <k, v>(k: k, defaultValue: BasicFun<Unit, v>, _: BasicUpdater<v>) => Updater<Map<k, v>>;
-    };
-    Operations: {
-        tryFirstWithError: <k, v, e>(m: Map<k, v>, e: () => e) => ValueOrErrors<v, e>;
-        tryFind: <k, v>(k: k, m: Map<k, v>) => Option<v>;
-        tryFindWithError: <k, v, e>(k: k, m: Map<k, v>, e: () => e) => ValueOrErrors<v, e>;
-    };
+  Default: {
+    fromIdentifiables: <T extends Identifiable>(array: T[]) => Map<T["Id"], T>;
+  };
+  Updaters: {
+    set<K, V>(key: K, value: V): Updater<Map<K, V>>;
+    remove<K, V>(key: K): Updater<Map<K, V>>;
+    update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<Map<k, v>>;
+    upsert: <k, v>(
+      k: k,
+      defaultValue: BasicFun<Unit, v>,
+      _: BasicUpdater<v>,
+    ) => Updater<Map<k, v>>;
+  };
+  Operations: {
+    tryFirstWithError: <k, v, e>(
+      m: Map<k, v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+    tryFind: <k, v>(k: k, m: Map<k, v>) => Option<v>;
+    tryFindWithError: <k, v, e>(
+      k: k,
+      m: Map<k, v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map