ballerina-core 1.0.222 → 1.0.224

package/bin/src/async/domains/mirroring/domains/collection/coroutines/synchronizers.js

@@ -1,338 +1,220 @@
-import {
-  CoTypedFactory,
-  AsyncState,
-  replaceWith,
-  Entity,
-  Debounced,
-} from "../../../../../../../main";
+import { CoTypedFactory, AsyncState, replaceWith, Entity, Debounced, } from "../../../../../../../main";
 import { Fun } from "../../../../../../fun/state";
 import { insideEntitySynchronizedAndDebounced } from "../../singleton/coroutines/synchronizers";
 import { Collection, CollectionEntity } from "../state";
-export const collectionEntityLoader =
-  (synchronizers) => (k, id, narrowing_k, widening_k, dependees) =>
-    Object.assign(
-      (mutation, mutationArg, entityId) => {
-        const Co = CoTypedFactory();
-        return Co.GetState().then((current) => {
-          const entities = narrowing_k(current).entities;
-          if (
-            !AsyncState.Operations.hasValue(entities.sync) ||
-            !entities.sync.value.get(entityId)
-          )
+export const collectionEntityLoader = (synchronizers) => (k, id, narrowing_k, widening_k, dependees) => Object.assign((mutation, mutationArg, entityId) => {
+    const Co = CoTypedFactory();
+    return Co.GetState().then((current) => {
+        const entities = narrowing_k(current).entities;
+        if (!AsyncState.Operations.hasValue(entities.sync) ||
+            !entities.sync.value.get(entityId))
             return Co.Return("completed");
-          return synchronizers[k][mutation](mutationArg)
-            .embed(
-              (_) => {
-                const entities = narrowing_k(_).entities;
-                if (AsyncState.Operations.hasValue(entities.sync)) {
-                  const entity = entities.sync.value.get(entityId);
-                  if (entity != undefined)
+        return synchronizers[k][mutation](mutationArg)
+            .embed((_) => {
+            const entities = narrowing_k(_).entities;
+            if (AsyncState.Operations.hasValue(entities.sync)) {
+                const entity = entities.sync.value.get(entityId);
+                if (entity != undefined)
                     return Object.assign(Object.assign({}, _), entity);
-                }
-                return undefined;
-              },
-              Fun(Collection().Updaters.Core.entity.set(entityId)).then(
-                widening_k,
-              ),
-            )
-            .then((syncResult) =>
-              Co.All(dependees).then((syncResults) =>
-                Co.Return(
-                  [syncResult, ...syncResults].some(
-                    (_) => _ == "should be enqueued again",
-                  )
-                    ? "should be enqueued again"
-                    : "completed",
-                ),
-              ),
-            );
-        });
-      },
-      {
-        add: (entityId, entity, position) => {
-          const Co = CoTypedFactory();
-          const CoColl = CoTypedFactory();
-          return CoColl.SetState((_) => {
+            }
+            return undefined;
+        }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k))
+            .then((syncResult) => Co.All(dependees).then((syncResults) => Co.Return([syncResult, ...syncResults].some((_) => _ == "should be enqueued again")
+            ? "should be enqueued again"
+            : "completed")));
+    });
+}, {
+    add: (entityId, entity, position) => {
+        const Co = CoTypedFactory();
+        const CoColl = CoTypedFactory();
+        return CoColl.SetState((_) => {
             // alert("state set?!?")
             // return Collection<Collections[k]>().Updaters.Core.entity.add([entityId, entity, position ?? { kind: "at the end" }])(_)
             return _;
-          })
-            .embed(
-              (_) => Object.assign(Object.assign({}, _), narrowing_k(_)),
-              widening_k,
-            )
-            .then(() =>
-              synchronizers[k]
-                .add(entity)
-                .embed(
-                  (_) => {
-                    const entities = narrowing_k(_).entities;
-                    if (AsyncState.Operations.hasValue(entities.sync)) {
-                      const entity = entities.sync.value.get(entityId);
-                      if (entity != undefined)
-                        return Object.assign(Object.assign({}, _), entity);
-                    }
-                    return undefined;
-                  },
-                  Fun(Collection().Updaters.Core.entity.set(entityId)).then(
-                    widening_k,
-                  ),
-                )
-                // )
-                // .then(_ =>
-                //   CoColl.GetState().then(current => {
-                //     if (!AsyncState.Operations.hasValue(current.entities.sync)) return CoColl.Return(unit)
-                //     const syncedEntity = current.entities.sync.value.get(entityId)
-                //     if (!syncedEntity || !AsyncState.Operations.hasValue(syncedEntity.value.value.sync)) return CoColl.Return(unit)
-                //     if (id(syncedEntity.value.value.sync.value) == entityId) return CoColl.Return(unit)
-                //     // otherwise, the id has changed (probably overridden by the API), let's save the new id
-                //     return CoColl.SetState(
-                //       Collection<Collections[k]>().Updaters.Core.entity.add([id(syncedEntity.value.value.sync.value), syncedEntity, position ?? { kind:"at the end" }]).then(
-                //         Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
-                //       )
-                //     )
-                //   }
-                //   )
-                //   .embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
-                .then((syncResult) =>
-                  Co.All(dependees).then((syncResults) =>
-                    Co.Return(
-                      [syncResult, ...syncResults].some(
-                        (_) => _ == "should be enqueued again",
-                      )
-                        ? "should be enqueued again"
-                        : "completed",
-                    ),
-                  ),
-                ),
-            );
-        },
-        remove: (entityId) => {
-          const Co = CoTypedFactory();
-          const CoColl = CoTypedFactory();
-          return CoColl.SetState(
-            // Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
-            Collection().Updaters.Core.removed(entityId, replaceWith(true)),
-          )
-            .embed(
-              (_) => Object.assign(Object.assign({}, _), narrowing_k(_)),
-              widening_k,
-            )
-            .then(() =>
-              synchronizers[k].remove(entityId).embed(
-                (_) => {
-                  const entities = narrowing_k(_).entities;
-                  if (AsyncState.Operations.hasValue(entities.sync)) {
-                    const entity = entities.sync.value.get(entityId);
-                    if (entity != undefined)
-                      return Object.assign(Object.assign({}, _), entity);
-                  }
-                  return undefined;
-                },
-                Fun(Collection().Updaters.Core.entity.set(entityId)).then(
-                  widening_k,
-                ),
-              ),
-            )
-            .then((_) =>
-              Co.GetState().then((current) => {
-                const entities = narrowing_k(current).entities;
-                if (!AsyncState.Operations.hasValue(entities.sync))
-                  return Co.Return("completed");
+        })
+            .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_))), widening_k)
+            .then(() => synchronizers[k]
+            .add(entity)
+            .embed((_) => {
+            const entities = narrowing_k(_).entities;
+            if (AsyncState.Operations.hasValue(entities.sync)) {
                 const entity = entities.sync.value.get(entityId);
-                if (!entity || entity.value.sync.kind == "error")
-                  return Co.Return("completed");
-                return Co.All(dependees).then((syncResults) =>
-                  Co.Return(
-                    syncResults.some((_) => _ == "should be enqueued again")
-                      ? "should be enqueued again"
-                      : "completed",
-                  ),
-                );
-              }),
-            );
-        },
-        wholeMutations: (mutation, mutationArg) => {
-          const Co = CoTypedFactory();
-          const CoColl = CoTypedFactory();
-          return CoColl.Seq([
-            synchronizers[k]["wholeMutations"]
-              [mutation](mutationArg)
-              .embed(
-                (_) => Object.assign(Object.assign({}, _), _.entities),
-                Collection().Updaters.Core.entities,
-              ),
-          ])
-            .embed(
-              (_) => Object.assign(Object.assign({}, _), narrowing_k(_)),
-              widening_k,
-            )
-            .then((syncResult) =>
-              Co.All(dependees).then((syncResults) =>
-                Co.Return(
-                  [syncResult, ...syncResults].some(
-                    (_) => _ == "should be enqueued again",
-                  )
-                    ? "should be enqueued again"
-                    : "completed",
-                ),
-              ),
-            );
-        },
-      },
-    );
-export const collectionDirtySetter =
-  () => (k, narrowing_k, widening_k) => (entityId, dirtyStatus) => {
+                if (entity != undefined)
+                    return Object.assign(Object.assign({}, _), entity);
+            }
+            return undefined;
+        }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k))
+            // )
+            // .then(_ =>
+            //   CoColl.GetState().then(current => {
+            //     if (!AsyncState.Operations.hasValue(current.entities.sync)) return CoColl.Return(unit)
+            //     const syncedEntity = current.entities.sync.value.get(entityId)
+            //     if (!syncedEntity || !AsyncState.Operations.hasValue(syncedEntity.value.value.sync)) return CoColl.Return(unit)
+            //     if (id(syncedEntity.value.value.sync.value) == entityId) return CoColl.Return(unit)
+            //     // otherwise, the id has changed (probably overridden by the API), let's save the new id
+            //     return CoColl.SetState(
+            //       Collection<Collections[k]>().Updaters.Core.entity.add([id(syncedEntity.value.value.sync.value), syncedEntity, position ?? { kind:"at the end" }]).then(
+            //         Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
+            //       )
+            //     )
+            //   }
+            //   )
+            //   .embed<Context & SynchronizedEntities, SynchronizedEntities>(_ => ({ ..._, ...(narrowing_k(_)) }), widening_k)
+            .then((syncResult) => Co.All(dependees).then((syncResults) => Co.Return([syncResult, ...syncResults].some((_) => _ == "should be enqueued again")
+            ? "should be enqueued again"
+            : "completed"))));
+    },
+    remove: (entityId) => {
+        const Co = CoTypedFactory();
+        const CoColl = CoTypedFactory();
+        return CoColl.SetState(
+        // Collection<Collections[k]>().Updaters.Core.entity.remove(entityId)
+        Collection().Updaters.Core.removed(entityId, replaceWith(true)))
+            .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_))), widening_k)
+            .then(() => synchronizers[k]
+            .remove(entityId)
+            .embed((_) => {
+            const entities = narrowing_k(_).entities;
+            if (AsyncState.Operations.hasValue(entities.sync)) {
+                const entity = entities.sync.value.get(entityId);
+                if (entity != undefined)
+                    return Object.assign(Object.assign({}, _), entity);
+            }
+            return undefined;
+        }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k)))
+            .then((_) => Co.GetState().then((current) => {
+            const entities = narrowing_k(current).entities;
+            if (!AsyncState.Operations.hasValue(entities.sync))
+                return Co.Return("completed");
+            const entity = entities.sync.value.get(entityId);
+            if (!entity || entity.value.sync.kind == "error")
+                return Co.Return("completed");
+            return Co.All(dependees).then((syncResults) => Co.Return(syncResults.some((_) => _ == "should be enqueued again")
+                ? "should be enqueued again"
+                : "completed"));
+        }));
+    },
+    wholeMutations: (mutation, mutationArg) => {
+        const Co = CoTypedFactory();
+        const CoColl = CoTypedFactory();
+        return CoColl.Seq([
+            synchronizers[k]["wholeMutations"][mutation](mutationArg)
+                .embed((_) => (Object.assign(Object.assign({}, _), _.entities)), Collection().Updaters.Core.entities),
+        ])
+            .embed((_) => (Object.assign(Object.assign({}, _), narrowing_k(_))), widening_k)
+            .then((syncResult) => Co.All(dependees).then((syncResults) => Co.Return([syncResult, ...syncResults].some((_) => _ == "should be enqueued again")
+            ? "should be enqueued again"
+            : "completed")));
+    },
+});
+export const collectionDirtySetter = () => (k, narrowing_k, widening_k) => (entityId, dirtyStatus) => {
     const CoEntity = CoTypedFactory();
     const Co = CoTypedFactory();
-    return CoEntity.SetState(
-      CollectionEntity().Updaters.Core.entity(
-        Entity().Updaters.Core.value(
-          Debounced.Updaters.Core.dirty(replaceWith(dirtyStatus)),
-        ),
-      ),
-    ).embed(
-      (_) => {
+    return CoEntity.SetState(CollectionEntity().Updaters.Core.entity(Entity().Updaters.Core.value(Debounced.Updaters.Core.dirty(replaceWith(dirtyStatus))))).embed((_) => {
         const _narrowed = narrowing_k(_);
         const entities = _narrowed.entities;
         if (AsyncState.Operations.hasValue(entities.sync)) {
-          const entity = entities.sync.value.get(entityId);
-          if (entity != undefined)
-            return Object.assign(Object.assign({}, _), entity);
+            const entity = entities.sync.value.get(entityId);
+            if (entity != undefined)
+                return Object.assign(Object.assign({}, _), entity);
         }
         return undefined;
-      },
-      Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k),
-    );
-  };
-export const collectionCheckNotDirty =
-  () =>
-  ([id, e]) => {
+    }, Fun(Collection().Updaters.Core.entity.set(entityId)).then(widening_k));
+};
+export const collectionCheckNotDirty = () => ([id, e]) => {
     var _a;
-    return (
-      AsyncState.Operations.hasValue(e.entities.sync) &&
-      ((_a = e.entities.sync.value.get(id)) === null || _a === void 0
-        ? void 0
-        : _a.value.dirty) != "not dirty"
-    );
-  };
-export const collectionEntityUpdater = () => (widening_k) =>
-  Fun(([id, u]) =>
-    widening_k(Collection().Updaters.Template.entityValue(id, u)),
-  );
+    return (AsyncState.Operations.hasValue(e.entities.sync) &&
+        ((_a = e.entities.sync.value.get(id)) === null || _a === void 0 ? void 0 : _a.value.dirty) != "not dirty");
+};
+export const collectionEntityUpdater = () => (widening_k) => Fun(([id, u]) => widening_k(Collection().Updaters.Template.entityValue(id, u)));
 export const withTrivialComparator = (_) => [_, (_) => "=="];
 export const collectionSynchronizationContext = (entityDescriptors) => {
-  let synchronizers = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    synchronizers[k] = {};
-    Object.keys(entityDescriptors[k]).forEach((field) => {
-      // only update the mutation fields of the entity descriptor
-      if (
-        field != "entityName" &&
-        field != "narrowing" &&
-        field != "widening" &&
-        field != "dependees" &&
-        field != "add" &&
-        field != "remove" &&
-        field != "default" &&
-        field != "reload" &&
-        field != "reloadElement"
-      )
-        synchronizers[k][field] = (mutationArg) => {
-          return insideEntitySynchronizedAndDebounced(
-            entityDescriptors[k][field](mutationArg),
-          );
-        };
+    let synchronizers = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        synchronizers[k] = {};
+        Object.keys(entityDescriptors[k]).forEach((field) => {
+            // only update the mutation fields of the entity descriptor
+            if (field != "entityName" &&
+                field != "narrowing" &&
+                field != "widening" &&
+                field != "dependees" &&
+                field != "add" &&
+                field != "remove" &&
+                field != "default" &&
+                field != "reload" &&
+                field != "reloadElement")
+                synchronizers[k][field] = (mutationArg) => {
+                    return insideEntitySynchronizedAndDebounced(entityDescriptors[k][field](mutationArg));
+                };
+        });
+        synchronizers[k]["add"] = (entity, position) => insideEntitySynchronizedAndDebounced(entityDescriptors[k]["add"](entity, position));
+        synchronizers[k]["remove"] = (entityId) => insideEntitySynchronizedAndDebounced(entityDescriptors[k]["remove"](entityId));
+        synchronizers[k]["wholeMutations"] = {};
+        Object.keys(entityDescriptors[k]["wholeMutations"]).forEach((field) => {
+            synchronizers[k]["wholeMutations"][field] = (mutationArg) => entityDescriptors[k]["wholeMutations"][field](mutationArg);
+        });
     });
-    synchronizers[k]["add"] = (entity, position) =>
-      insideEntitySynchronizedAndDebounced(
-        entityDescriptors[k]["add"](entity, position),
-      );
-    synchronizers[k]["remove"] = (entityId) =>
-      insideEntitySynchronizedAndDebounced(
-        entityDescriptors[k]["remove"](entityId),
-      );
-    synchronizers[k]["wholeMutations"] = {};
-    Object.keys(entityDescriptors[k]["wholeMutations"]).forEach((field) => {
-      synchronizers[k]["wholeMutations"][field] = (mutationArg) =>
-        entityDescriptors[k]["wholeMutations"][field](mutationArg);
+    const loaders = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        loaders[k] = collectionEntityLoader(synchronizers)(k, entityDescriptors[k].id, entityDescriptors[k].narrowing, entityDescriptors[k].widening, entityDescriptors[k].dependees);
     });
-  });
-  const loaders = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    loaders[k] = collectionEntityLoader(synchronizers)(
-      k,
-      entityDescriptors[k].id,
-      entityDescriptors[k].narrowing,
-      entityDescriptors[k].widening,
-      entityDescriptors[k].dependees,
-    );
-  });
-  const dirtyCheckers = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    dirtyCheckers[k] = Fun(collectionCheckNotDirty());
-  });
-  const dirtySetters = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    dirtySetters[k] = collectionDirtySetter()(
-      k,
-      entityDescriptors[k].narrowing,
-      entityDescriptors[k].widening,
-    );
-  });
-  const updaters = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    updaters[k] = collectionEntityUpdater()(entityDescriptors[k].widening);
-  });
-  const mutationComparators = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    mutationComparators[k] = {};
-    Object.keys(entityDescriptors[k]).forEach((field) => {
-      if (
-        field != "entityName" &&
-        field != "narrowing" &&
-        field != "widening" &&
-        field != "dependees" &&
-        field != "add" &&
-        field != "remove" &&
-        field != "default" &&
-        field != "reload"
-      )
-        mutationComparators[k][field] = entityDescriptors[k][field][1];
+    const dirtyCheckers = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        dirtyCheckers[k] = Fun(collectionCheckNotDirty());
     });
-  });
-  const wholeMutationComparators = {};
-  Object.keys(entityDescriptors).forEach((k_s) => {
-    const k = k_s;
-    wholeMutationComparators[k] = {};
-    Object.keys(entityDescriptors[k]).forEach((field) => {
-      if (
-        field != "entityName" &&
-        field != "narrowing" &&
-        field != "widening" &&
-        field != "dependees" &&
-        field != "add" &&
-        field != "remove" &&
-        field != "default" &&
-        field != "reload"
-      )
-        wholeMutationComparators[k][field] = entityDescriptors[k][field][1];
+    const dirtySetters = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        dirtySetters[k] = collectionDirtySetter()(k, entityDescriptors[k].narrowing, entityDescriptors[k].widening);
+    });
+    const updaters = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        updaters[k] = collectionEntityUpdater()(entityDescriptors[k].widening);
+    });
+    const mutationComparators = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        mutationComparators[k] = {};
+        Object.keys(entityDescriptors[k]).forEach((field) => {
+            if (field != "entityName" &&
+                field != "narrowing" &&
+                field != "widening" &&
+                field != "dependees" &&
+                field != "add" &&
+                field != "remove" &&
+                field != "default" &&
+                field != "reload")
+                mutationComparators[k][field] = entityDescriptors[k][field][1];
+        });
+    });
+    const wholeMutationComparators = {};
+    Object.keys(entityDescriptors).forEach((k_s) => {
+        const k = k_s;
+        wholeMutationComparators[k] = {};
+        Object.keys(entityDescriptors[k]).forEach((field) => {
+            if (field != "entityName" &&
+                field != "narrowing" &&
+                field != "widening" &&
+                field != "dependees" &&
+                field != "add" &&
+                field != "remove" &&
+                field != "default" &&
+                field != "reload")
+                wholeMutationComparators[k][field] = entityDescriptors[k][field][1];
+        });
     });
-  });
-  return [
-    loaders,
-    dirtyCheckers,
-    dirtySetters,
-    updaters,
-    entityDescriptors,
-    mutationComparators,
-    wholeMutationComparators,
-  ];
+    return [
+        loaders,
+        dirtyCheckers,
+        dirtySetters,
+        updaters,
+        entityDescriptors,
+        mutationComparators,
+        wholeMutationComparators,
+    ];
 };
-//# sourceMappingURL=synchronizers.js.map
+//# sourceMappingURL=synchronizers.js.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