ballerina-core 1.0.215 → 1.0.217

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

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