@awesome-ecs/abstract 0.21.0 → 0.21.1

package/dist/entity-repository-DJ1xbvaN.d.cts

@@ -1,253 +0,0 @@
-import { I as IEntityProxy, f as IdentityComponent, b as IEntityModel, g as IComponent, c as IEntity, E as EntityTypeUid } from './index-CnlpX7ys.cjs';
-
-/**
- * Represents a unique identifier for an entity event.
- * Can be either a string or a number.
- */
-type EntityEventUid = string | number;
-/**
- * A filter function for entity event subscriptions.
- * Returns true if the event should be processed, false otherwise.
- */
-type EntityEventSubscriptionFilter = (event: IEntityEvent<IEventData>) => boolean;
-/**
- * The `IEventData` interface represents the data associated with an entity event.
- * It contains at least the `Event Unique Identifier`.
- */
-interface IEventData {
-    uid: EntityEventUid;
-}
-/**
- * The `IEntityEvent` interface represents a basic building block for a Publish/Subscribe pattern.
- * It is used to synchronize state between multiple entities.
- *
- * The events are scheduled as part of the `EntityUpdate` model.
- * Systems subscribe and receive updates with the events included in their `SystemContext`.
- */
-interface IEntityEvent<TEventData extends IEventData> {
-    origin: IEntityProxy;
-    target?: IEntityProxy;
-    data: TEventData;
-}
-/**
- * The `IEntityEventsManager` interface represents a Publish/Subscribe broker for `IEntityEvent` instances.
- * It keeps track of entity subscriptions (as part of the Observer design pattern).
- */
-interface IEntityEventsManager {
-    /**
-     * Subscribes an entity to a specific event.
-     * @param uid - The unique identifier of the event.
-     * @param entity - The entity subscribing to the event.
-     * @param filter - An optional filter function to determine if the event should be processed.
-     */
-    subscribe(uid: EntityEventUid, entity: IEntityProxy, filter?: EntityEventSubscriptionFilter): void;
-    /**
-     * Unsubscribes an entity from a specific event.
-     * @param uid - The unique identifier of the event.
-     * @param entity - The entity unsubscribing from the event.
-     */
-    unsubscribe(uid: EntityEventUid, entity: IEntityProxy): void;
-    /**
-     * Retrieves the entities subscribed to a specific event.
-     * @param event - The event to retrieve subscriptions for.
-     * @returns An array of entities subscribed to the event.
-     */
-    getSubscriptions(event: IEntityEvent<IEventData>): IEntityProxy[];
-    /**
-     * Retrieves the unique identifiers of events subscribed to by a specific entity.
-     * @param entity - The entity to retrieve subscriptions for.
-     * @returns An array of unique identifiers of events subscribed to by the entity.
-     */
-    getSubscriptionsForEntity(entity: IEntityProxy): EntityEventUid[];
-    /**
-     * Removes all subscriptions for all entities.
-     */
-    clearSubscriptions(): void;
-    /**
-     * Removes all subscriptions for a specific event.
-     * @param uid - The unique identifier of the event to remove subscriptions from.
-     */
-    clearSubscriptionsForEvent(uid: EntityEventUid): void;
-    /**
-     * Removes all subscriptions for a specific entity.
-     * @param entity - The entity to remove subscriptions from.
-     */
-    clearSubscriptionsForEntity(entity: IEntityProxy): void;
-}
-/**
- * The `IEntityEventsDispatcher` interface represents the main access point for dispatching events to entities.
- * It can leverage the `IEntityEventsManager` to find subscribers and the `IEntityUpdateQueue` to register events
- * into each observer entity's next update.
- */
-interface IEntityEventsDispatcher {
-    /**
-     * Dispatches a single event to entities.
-     * @param event - The event to dispatch.
-     * @param targets - The entities to dispatch the event to.
-     */
-    dispatchEvent(event: IEntityEvent<IEventData>, ...targets: IEntityProxy[]): void;
-    /**
-     * Dispatches multiple events to entities.
-     * @param events - The events to dispatch.
-     * @param targets - The entities to dispatch the events to.
-     */
-    dispatchEvents(events: IEntityEvent<IEventData>[], ...targets: IEntityProxy[]): void;
-}
-
-/**
- * The `IEntitySnapshot` interface represents a serializable state of an Entity.
- * It can contain the full or partial state of the Entity, including its identity, components, proxies, and events.
- * This interface is used to capture Entity state changes (deltas) or update existing Entity with changes from a remote source.
- */
-interface IEntitySnapshot {
-    /**
-     * The identity of the Entity.
-     */
-    readonly identity?: Readonly<IdentityComponent<IEntityModel>>;
-    /**
-     * An array of components associated with the Entity.
-     */
-    readonly components?: IComponent[];
-    /**
-     * An array of proxies associated with the Entity.
-     */
-    readonly proxies?: IEntityProxy[];
-    /**
-     * An array of events associated with the Entity.
-     */
-    readonly events?: IEntityEvent<IEventData>[];
-}
-/**
- * The `IEntitySnapshotProvider` interface is the main provider for creating and updating Entity snapshots.
- * It provides methods to apply a snapshot to an Entity and to create a snapshot from an Entity.
- */
-interface IEntitySnapshotProvider {
-    /**
-     * Applies a snapshot to an Entity.
-     * This method updates the Entity's state based on the provided snapshot.
-     *
-     * @param entity - The Entity to apply the snapshot to.
-     * @param snapshot - The snapshot to apply to the Entity.
-     */
-    applySnapshot(entity: IEntity, snapshot: IEntitySnapshot): void;
-    /**
-     * Creates a snapshot from an Entity.
-     * This method captures the current state of the Entity and returns it as a snapshot.
-     *
-     * @param entity - The Entity to create a snapshot from.
-     * @returns The created snapshot.
-     */
-    createSnapshot(entity: IEntity): IEntitySnapshot;
-}
-
-/**
- * The `EntityUpdateType` enum specifies whether the current Entity should be `updated` or `removed`.
- */
-declare enum EntityUpdateType {
-    update = "update",
-    remove = "remove"
-}
-/**
- * The `IEntityUpdate` interface represents an Entity update that should be applied over an existing Entity.
- */
-interface IEntityUpdate {
-    /**
-     * The type of the update, which can be either `update` or `remove`.
-     */
-    type: EntityUpdateType;
-    /**
-     * The proxy of the Entity that needs to be updated.
-     */
-    entity: IEntityProxy;
-    /**
-     * Optional. The model of the Entity that needs to be updated.
-     */
-    model?: IEntityModel;
-    /**
-     * Optional. The snapshot of the Entity that needs to be updated.
-     */
-    snapshot?: IEntitySnapshot;
-}
-/**
- * The `IEntityUpdateQueue` interface is the main mechanism to queue and retrieve `EntityUpdate` instances.
- *
- * The interface can be implemented using a simple queue mechanism, or perhaps, a Priority Queue.
- */
-interface IEntityUpdateQueue {
-    /**
-     * The number of `EntityUpdate` instances currently in the queue.
-     */
-    readonly size: number;
-    /**
-     * Adds an `EntityUpdate` instance to the end of the queue.
-     * @param change - The `EntityUpdate` instance to be added.
-     */
-    enqueue(change: IEntityUpdate): void;
-    /**
-     * Removes and returns the `EntityUpdate` instance at the front of the queue.
-     * @returns The `EntityUpdate` instance at the front of the queue.
-     */
-    dequeue(): IEntityUpdate;
-    /**
-     * Returns the `EntityUpdate` instance at the front of the queue without removing it.
-     * @returns The `EntityUpdate` instance at the front of the queue.
-     */
-    peek(): IEntityUpdate;
-    /**
-     * Removes all `EntityUpdate` instances from the queue.
-     */
-    clear(): void;
-}
-
-/**
- * The `IEntityRepository` is the central storage for keeping track of existing Entities.
- * It provides basic CRUD functionality.
- */
-interface IEntityRepository {
-    /**
-     * Returns the number of entities in the repository.
-     */
-    readonly size: number;
-    /**
-     * Checks if the repository contains an entity represented by the given proxy.
-     * @param proxy - The proxy of the entity to check.
-     * @returns True if the repository contains the entity, false otherwise.
-     */
-    has(proxy: IEntityProxy): boolean;
-    /**
-     * Retrieves an entity from the repository by its proxy.
-     * @template TEntity - The type of the entity to retrieve.
-     * @param proxy - The proxy of the entity to retrieve.
-     * @returns The retrieved entity.
-     */
-    get<TEntity extends IEntity>(proxy: IEntityProxy): TEntity;
-    /**
-     * Retrieves all entities of a specific type from the repository.
-     * @template TEntity - The type of the entities to retrieve.
-     * @param entityType - The type UID of the entities to retrieve.
-     * @returns An array of the retrieved entities.
-     */
-    getAll<TEntity extends IEntity>(entityType: EntityTypeUid): TEntity[];
-    /**
-     * Iterator over all entities in the repository.
-     * @returns An iterator of all entities in the repository.
-     */
-    listAll(): IterableIterator<IEntity>;
-    /**
-     * Adds or updates an entity in the repository.
-     * @param entity - The entity to add or update.
-     */
-    set(entity: IEntity): void;
-    /**
-     * Deletes an entity from the repository by its proxy.
-     * @param proxy - The proxy of the entity to delete.
-     */
-    delete(proxy: IEntityProxy): void;
-    /**
-     * Clears all entities of a specific type from the repository.
-     * @param entityType - The type UID of the entities to clear.
-     */
-    clear(entityType: EntityTypeUid): void;
-}
-
-export { type EntityEventUid as E, type IEventData as I, type EntityEventSubscriptionFilter as a, type IEntityEvent as b, type IEntityEventsManager as c, type IEntityEventsDispatcher as d, EntityUpdateType as e, type IEntityUpdate as f, type IEntityUpdateQueue as g, type IEntityRepository as h, type IEntitySnapshot as i, type IEntitySnapshotProvider as j };

package/dist/factories/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/factories/index.ts"],"sourcesContent":["export * from './context-factory';\nexport * from './pipeline-factory';\n"],"mappings":";;;;;;;;;;;;;;;AAAA;AAAA;","names":[]}

package/dist/factories/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index-B1KXekZD.d.ts

@@ -1,199 +0,0 @@
-import { B as BooleanProps, I as Immutable } from './types-cZ-1lGPD.js';
-
-type ComponentTypeUid = string | number;
-/**
- * The `IComponent` interface provides the main storage mechanism of `IEntity` state, and can be accessed and modified by `Systems`.
- *
- * The `IComponent` implementations should not contain any logic methods, apart from quick-access functionality.
- */
-interface IComponent {
-    /**
-     * The `ComponentTypeUid` is a unique identifier for each Component type.
-     * @type {ComponentTypeUid}
-     */
-    readonly componentType: ComponentTypeUid;
-    /**
-     * Specifies whether the Component state should be serialized as part of an `IEntitySnapshot`.
-     * This is useful if the state needs to be replicated or updated through remote updates (e.g., coming from the server or peers).
-     * @type {boolean}
-     */
-    readonly isSerializable: boolean;
-    /**
-     * @optional
-     * Specifies the current version of the component.
-     * This is useful for keeping backwards-compatibility when the stored state might be of a different version.
-     * @type {number}
-     */
-    readonly version?: number;
-    /**
-     * @optional
-     * The custom serialization function of this Component, used to transfer it into a Snapshot, or used for logging the Component stored state.
-     * If not provided, the standard `JSON.stringify()` functionality applies.
-     * @returns {string | object} The serialized form of the Component.
-     */
-    toJSON?(): string | object;
-    /**
-     * Allows for custom logic when loading the current from an `IEntitySnapshot`.
-     * The default behavior simply overwrites the fields with the target state.
-     * @param {this} targetState The target state to load from.
-     */
-    load?(targetState: this): void;
-}
-
-/**
- * The `IEntityProxy` represents a pointer to another `Entity`.
- */
-interface IEntityProxy {
-    /**
-     * The type of the entity that the proxy points to.
-     */
-    readonly entityType: EntityTypeUid;
-    /**
-     * The unique identifier of the entity that the proxy points to.
-     */
-    readonly entityUid: EntityUid;
-}
-/**
- * A utility extension of `IEntityProxy`.
- * Useful for providing strong `Type` information when using the IEntityProxy.
- *
- * @template TEntity - The type of the entity that the proxy points to.
- */
-interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {
-}
-/**
- * The `IEntityProxiesManager` is a helper to encapsulate logic for registering & removing Entity proxies.
- *
- * It handles the complexities of bi-directional registrations and offers an abstraction for the Proxy handling.
- */
-interface IEntityProxiesManager {
-    /**
-     * Registers a single proxy for an entity.
-     *
-     * @param entity - The entity to register the proxy for.
-     * @param proxy - The proxy to register.
-     * @param cleanup - If true, any existing proxies of the same type will be removed before registering the new one.
-     */
-    registerProxy(entity: IEntity, proxy: IEntityProxy, cleanup?: boolean): void;
-    /**
-     * Registers multiple proxies for an entity.
-     *
-     * @param entity - The entity to register the proxies for.
-     * @param proxies - The proxies to register.
-     * @param cleanup - If true, any existing proxies of the same type will be removed before registering the new ones.
-     */
-    registerProxies(entity: IEntity, proxies: IEntityProxy[], cleanup?: boolean): void;
-    /**
-     * Removes a single proxy from an entity.
-     *
-     * @param entity - The entity to remove the proxy from.
-     * @param proxy - The proxy to remove.
-     */
-    removeProxy(entity: IEntity, proxy: IEntityProxy): void;
-    /**
-     * Removes all proxies from an entity, optionally filtering by proxy entity type.
-     *
-     * @param entity - The entity to remove the proxies from.
-     * @param proxyEntityType - The type of the proxy entity to filter by.
-     */
-    removeProxies(entity: IEntity, proxyEntityType?: EntityTypeUid): void;
-}
-
-/**
- * Represents the unique identifier for an entity type.
- * Can be either a string or a number.
- */
-type EntityTypeUid = string | number;
-/**
- * Represents the unique identifier for an entity.
- * Can be either a string or a number.
- */
-type EntityUid = string | number;
-/**
- * The `IEntityModel` represents the basic identity information about the current `IEntity`.
- * It's mandatory for each Entity, and it contains the minimal-required information needed for instantiating the Entity.
- *
- * The Features property can be used to toggle Entity features on and off.
- *
- * @template TFeatures - A type that extends `BooleanProps<TFeatures>` to represent the features of the entity.
- *                      Defaults to `unknown` if not provided.
- */
-interface IEntityModel<TFeatures extends BooleanProps<TFeatures> = unknown> {
-    /**
-     * The unique identifier of the entity.
-     */
-    readonly uid: EntityUid;
-    /**
-     * Optional features of the entity.
-     * The type of this property should extend `BooleanProps<TFeatures>`.
-     */
-    readonly features?: TFeatures;
-}
-/**
- * The `IEntity` interface represents a container of Components and Entity Proxies.
- * It is designed to be immutable and only modifiable through System operations.
- *
- * Implementations of `IEntity` can contain quick-access methods for `Components` or `Proxies`,
- * but should not contain any state-changing logic apart from quick-access functionality.
- */
-interface IEntity {
-    /**
-     * A Map of Components associated with this Entity.
-     * The keys are ComponentTypeUid, and the values are IComponent instances.
-     */
-    readonly components: Map<ComponentTypeUid, IComponent>;
-    /**
-     * A Map of Entity Proxies associated with this Entity.
-     * The outer Map's keys are EntityTypeUid, and the inner Map's keys are EntityUid.
-     * The values are IEntityProxy instances.
-     */
-    readonly proxies: Map<EntityTypeUid, Map<EntityUid, IEntityProxy>>;
-    /**
-     * The IdentityComponent represents mandatory state any Entity needs to have.
-     * It is a readonly reference to an IdentityComponent instance, which contains the minimal-required information
-     * needed for instantiating the Entity.
-     */
-    readonly identity: Readonly<IdentityComponent<IEntityModel>>;
-    /**
-     * A reference to the own Proxy of this Entity.
-     * It is a readonly reference to an IEntityProxy instance, which points to this Entity.
-     * This is useful for quick access of Proxy data.
-     */
-    readonly myProxy: Readonly<IEntityProxy>;
-}
-
-/**
- * The `BasicComponentType` enum defines the types of basic components available.
- */
-declare enum BasicComponentType {
-    identity = "identity"
-}
-/**
- * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.
- * It extends the IComponent interface.
- *
- * @template TModel - The type of the model that extends IEntityModel.
- */
-interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
-    /**
-     * The Entity Type that defines what Category type the Entity is part of.
-     * There can be multiple Entities sharing the same EntityType.
-     */
-    readonly entityType: EntityTypeUid;
-    /**
-     * The Model is the basic information needed to create an `IEntity` when it's first initialized.
-     * It provides a first snapshot of information needed for the successful creation of an Entity instance.
-     *
-     * @type {Immutable<TModel>}
-     */
-    readonly model: Immutable<TModel>;
-    /**
-     * Keeps track when the Entity's systems have ran last.
-     * Useful to calculate the `DeltaTime` between runs.
-     *
-     * @type {Date | undefined}
-     */
-    readonly lastUpdated?: Date;
-}
-
-export { BasicComponentType as B, type ComponentTypeUid as C, type EntityTypeUid as E, type IEntityProxy as I, type EntityUid as a, type IEntityModel as b, type IEntity as c, type EntityProxy as d, type IEntityProxiesManager as e, type IdentityComponent as f, type IComponent as g };

package/dist/index-CnlpX7ys.d.cts

@@ -1,199 +0,0 @@
-import { B as BooleanProps, I as Immutable } from './types-cZ-1lGPD.cjs';
-
-type ComponentTypeUid = string | number;
-/**
- * The `IComponent` interface provides the main storage mechanism of `IEntity` state, and can be accessed and modified by `Systems`.
- *
- * The `IComponent` implementations should not contain any logic methods, apart from quick-access functionality.
- */
-interface IComponent {
-    /**
-     * The `ComponentTypeUid` is a unique identifier for each Component type.
-     * @type {ComponentTypeUid}
-     */
-    readonly componentType: ComponentTypeUid;
-    /**
-     * Specifies whether the Component state should be serialized as part of an `IEntitySnapshot`.
-     * This is useful if the state needs to be replicated or updated through remote updates (e.g., coming from the server or peers).
-     * @type {boolean}
-     */
-    readonly isSerializable: boolean;
-    /**
-     * @optional
-     * Specifies the current version of the component.
-     * This is useful for keeping backwards-compatibility when the stored state might be of a different version.
-     * @type {number}
-     */
-    readonly version?: number;
-    /**
-     * @optional
-     * The custom serialization function of this Component, used to transfer it into a Snapshot, or used for logging the Component stored state.
-     * If not provided, the standard `JSON.stringify()` functionality applies.
-     * @returns {string | object} The serialized form of the Component.
-     */
-    toJSON?(): string | object;
-    /**
-     * Allows for custom logic when loading the current from an `IEntitySnapshot`.
-     * The default behavior simply overwrites the fields with the target state.
-     * @param {this} targetState The target state to load from.
-     */
-    load?(targetState: this): void;
-}
-
-/**
- * The `IEntityProxy` represents a pointer to another `Entity`.
- */
-interface IEntityProxy {
-    /**
-     * The type of the entity that the proxy points to.
-     */
-    readonly entityType: EntityTypeUid;
-    /**
-     * The unique identifier of the entity that the proxy points to.
-     */
-    readonly entityUid: EntityUid;
-}
-/**
- * A utility extension of `IEntityProxy`.
- * Useful for providing strong `Type` information when using the IEntityProxy.
- *
- * @template TEntity - The type of the entity that the proxy points to.
- */
-interface EntityProxy<TEntity extends IEntity> extends IEntityProxy {
-}
-/**
- * The `IEntityProxiesManager` is a helper to encapsulate logic for registering & removing Entity proxies.
- *
- * It handles the complexities of bi-directional registrations and offers an abstraction for the Proxy handling.
- */
-interface IEntityProxiesManager {
-    /**
-     * Registers a single proxy for an entity.
-     *
-     * @param entity - The entity to register the proxy for.
-     * @param proxy - The proxy to register.
-     * @param cleanup - If true, any existing proxies of the same type will be removed before registering the new one.
-     */
-    registerProxy(entity: IEntity, proxy: IEntityProxy, cleanup?: boolean): void;
-    /**
-     * Registers multiple proxies for an entity.
-     *
-     * @param entity - The entity to register the proxies for.
-     * @param proxies - The proxies to register.
-     * @param cleanup - If true, any existing proxies of the same type will be removed before registering the new ones.
-     */
-    registerProxies(entity: IEntity, proxies: IEntityProxy[], cleanup?: boolean): void;
-    /**
-     * Removes a single proxy from an entity.
-     *
-     * @param entity - The entity to remove the proxy from.
-     * @param proxy - The proxy to remove.
-     */
-    removeProxy(entity: IEntity, proxy: IEntityProxy): void;
-    /**
-     * Removes all proxies from an entity, optionally filtering by proxy entity type.
-     *
-     * @param entity - The entity to remove the proxies from.
-     * @param proxyEntityType - The type of the proxy entity to filter by.
-     */
-    removeProxies(entity: IEntity, proxyEntityType?: EntityTypeUid): void;
-}
-
-/**
- * Represents the unique identifier for an entity type.
- * Can be either a string or a number.
- */
-type EntityTypeUid = string | number;
-/**
- * Represents the unique identifier for an entity.
- * Can be either a string or a number.
- */
-type EntityUid = string | number;
-/**
- * The `IEntityModel` represents the basic identity information about the current `IEntity`.
- * It's mandatory for each Entity, and it contains the minimal-required information needed for instantiating the Entity.
- *
- * The Features property can be used to toggle Entity features on and off.
- *
- * @template TFeatures - A type that extends `BooleanProps<TFeatures>` to represent the features of the entity.
- *                      Defaults to `unknown` if not provided.
- */
-interface IEntityModel<TFeatures extends BooleanProps<TFeatures> = unknown> {
-    /**
-     * The unique identifier of the entity.
-     */
-    readonly uid: EntityUid;
-    /**
-     * Optional features of the entity.
-     * The type of this property should extend `BooleanProps<TFeatures>`.
-     */
-    readonly features?: TFeatures;
-}
-/**
- * The `IEntity` interface represents a container of Components and Entity Proxies.
- * It is designed to be immutable and only modifiable through System operations.
- *
- * Implementations of `IEntity` can contain quick-access methods for `Components` or `Proxies`,
- * but should not contain any state-changing logic apart from quick-access functionality.
- */
-interface IEntity {
-    /**
-     * A Map of Components associated with this Entity.
-     * The keys are ComponentTypeUid, and the values are IComponent instances.
-     */
-    readonly components: Map<ComponentTypeUid, IComponent>;
-    /**
-     * A Map of Entity Proxies associated with this Entity.
-     * The outer Map's keys are EntityTypeUid, and the inner Map's keys are EntityUid.
-     * The values are IEntityProxy instances.
-     */
-    readonly proxies: Map<EntityTypeUid, Map<EntityUid, IEntityProxy>>;
-    /**
-     * The IdentityComponent represents mandatory state any Entity needs to have.
-     * It is a readonly reference to an IdentityComponent instance, which contains the minimal-required information
-     * needed for instantiating the Entity.
-     */
-    readonly identity: Readonly<IdentityComponent<IEntityModel>>;
-    /**
-     * A reference to the own Proxy of this Entity.
-     * It is a readonly reference to an IEntityProxy instance, which points to this Entity.
-     * This is useful for quick access of Proxy data.
-     */
-    readonly myProxy: Readonly<IEntityProxy>;
-}
-
-/**
- * The `BasicComponentType` enum defines the types of basic components available.
- */
-declare enum BasicComponentType {
-    identity = "identity"
-}
-/**
- * IdentityComponent interface represents the basic information regarding what makes the current Entity unique.
- * It extends the IComponent interface.
- *
- * @template TModel - The type of the model that extends IEntityModel.
- */
-interface IdentityComponent<TModel extends IEntityModel> extends IComponent {
-    /**
-     * The Entity Type that defines what Category type the Entity is part of.
-     * There can be multiple Entities sharing the same EntityType.
-     */
-    readonly entityType: EntityTypeUid;
-    /**
-     * The Model is the basic information needed to create an `IEntity` when it's first initialized.
-     * It provides a first snapshot of information needed for the successful creation of an Entity instance.
-     *
-     * @type {Immutable<TModel>}
-     */
-    readonly model: Immutable<TModel>;
-    /**
-     * Keeps track when the Entity's systems have ran last.
-     * Useful to calculate the `DeltaTime` between runs.
-     *
-     * @type {Date | undefined}
-     */
-    readonly lastUpdated?: Date;
-}
-
-export { BasicComponentType as B, type ComponentTypeUid as C, type EntityTypeUid as E, type IEntityProxy as I, type EntityUid as a, type IEntityModel as b, type IEntity as c, type EntityProxy as d, type IEntityProxiesManager as e, type IdentityComponent as f, type IComponent as g };