angry-pixel 2.0.0 → 2.0.1

package/lib/index.d.ts

@@ -1,6 +1,16 @@
+/**
+ * This type represents a dependency class
+ * @public
+ * @category Core
+ */
 type DependencyType = {
     new (...args: any[]): any;
 };
+/**
+ * This type represents a dependency name
+ * @public
+ * @category Core
+ */
 type DependencyName = string | symbol;
 type PropertyKey = string | symbol;
 declare class Container {
@@ -11,7 +21,40 @@ declare class Container {
     get<T>(name: DependencyName): T;
     has(name: DependencyName): boolean;
 }
+/**
+ * Decorator to identify a class as an injectable dependency
+ * @param name the name to identify the dependency
+ * @public
+ * @category Decorators
+ * @example
+ * ```typescript
+ * @injectable("SomeDependency")
+ * class SomeDependency {}
+ * ```
+ */
 declare function injectable(name: DependencyName): (target: DependencyType) => void;
+/**
+ * Decorator to identify a property, or constructor argument, as a dependency to be injected
+ * @param name the name to identify the dependency
+ * @public
+ * @category Decorators
+ * @example
+ * ```typescript
+ * class SomeClass {
+ *   private anotherDependency: DependencyType;
+ *
+ *   constructor(@inject("AnotherDependency") anotherDependency: DependencyType) {
+ *     this.anotherDependency = anotherDependency;
+ *   }
+ * }
+ * ```
+ * @example
+ * ```typescript
+ * class SomeClass {
+ *   @inject("AnotherDependency") private anotherDependency: DependencyType;
+ * }
+ * ```
+ */
 declare function inject(name: DependencyName): (target: any, propertyKey: PropertyKey, parameterIndex?: number) => void;
 
 /**
@@ -329,6 +372,7 @@ declare const range: (start: number, end: number, steps?: number) => number[];
  */
 declare const between: (value: number, min: number, max: number) => boolean;
 
+/** @internal */
 interface Shape {
     boundingBox: Rectangle;
     collider: number;
@@ -344,6 +388,7 @@ interface Shape {
     vertices: Vector2[];
     updateCollisions: boolean;
 }
+/** @internal */
 declare class Polygon implements Shape {
     rotation: number;
     boundingBox: Rectangle;
@@ -362,6 +407,7 @@ declare class Polygon implements Shape {
     set vertexModel(vertexModel: Vector2[]);
     constructor(vertexModel: Vector2[], rotation?: number);
 }
+/** @internal */
 declare class Circumference implements Shape {
     radius: number;
     boundingBox: Rectangle;
@@ -391,8 +437,21 @@ declare enum BroadPhaseMethods {
     SpartialGrid = 1
 }
 
+/**
+ * Contains information about the collision
+ * @public
+ * @category Collisions
+ */
 interface CollisionResolution {
+    /**
+     * Intersection between both colliders expressed in pixels
+     * @public
+     */
     penetration: number;
+    /**
+     * Collision direction
+     * @public
+     */
     direction: Vector2;
 }
 
@@ -408,105 +467,590 @@ declare enum CollisionMethods {
     SAT = 1
 }
 
+/**
+ * Interface implemented by the collider components
+ * @public
+ * @category Collisions
+ */
 interface Collider {
+    /** Ignores collisions with layers in the array */
     ignoreCollisionsWithLayers: string[];
+    /** Collision layer*/
     layer: string;
+    /** X-Y axis offset */
     offset: Vector2;
+    /** TRUE if this collider interact with rigid bodies */
     physics: boolean;
+    /** @internal */
     shapes: Shape[];
 }
 
+/**
+ * This type an unique identifier of an Entity
+ * @public
+ * @category Core
+ */
 type Entity = number;
+/**
+ * This type represents an instance of a component
+ * @public
+ * @category Core
+ */
 type Component = {
     [key: string]: any;
 };
+/**
+ * This type represents a component class
+ * @public
+ * @category Core
+ */
 type ComponentType<T extends Component = Component> = {
     new (...args: any[]): T;
 };
+/**
+ * This type represents a search result object
+ * @public
+ * @category Core
+ */
 type SearchResult<T extends Component> = {
     entity: Entity;
     component: T;
 };
+/**
+ * This type represents a search criteria object
+ * @public
+ * @category Core
+ */
 type SearchCriteria = {
     [key: string]: any;
 };
+/**
+ * The EntityManager manages the entities and components.\
+ * It provides the necessary methods for reading and writing entities and components.
+ * @public
+ * @category Core
+ */
 declare class EntityManager {
     private lastEntityId;
     private lastComponentTypeId;
     private components;
     private disabledEntities;
     private disabledComponents;
+    /**
+     * Creates an entity without component
+     * @return the created Entity
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const entity = entityManager.createEntity();
+     * ```
+     */
     createEntity(): Entity;
+    /**
+     * Creates an Entity based on a collection of Component instances and ComponentTypes
+     * @param components A collection of Component instances and ComponentTypes
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const entity = entityManager.createEntity([
+     *   new Transform({position: new Vector2(100, 100)}),
+     *   SpriteRenderer
+     * ]);
+     * ```
+     */
     createEntity(components: Array<ComponentType | Component>): Entity;
+    /**
+     * Removes an Entity and all its Components
+     * @param entity The entity to remove
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.removeEntity(entity);
+     * ```
+     */
     removeEntity(entity: Entity): void;
+    /**
+     * Removes all Entities and all their Components
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.removeAllEntities();
+     * ```
+     */
     removeAllEntities(): void;
+    /**
+     * Returns TRUE if the Entity is enabled, otherwise it returns FALSE
+     * @param entity The entity to verify
+     * @returns boolean
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const entityEnabled = entityManager.isEntityEnabled(entity);
+     * ```
+     */
     isEntityEnabled(entity: Entity): boolean;
+    /**
+     * Enables an Entity
+     * @param entity The entity to be enabled
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.enableEntity(entity);
+     * ```
+     */
     enableEntity(entity: Entity): void;
+    /**
+     * Disables an Entity
+     * @param entity The entity to be disabled
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.disableEntity(entity);
+     * ```
+     */
     disableEntity(entity: Entity): void;
+    /**
+     * Disable all Entities that have a component of the given type
+     * @param componentType The class of the component
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.disableEntitiesByComponent(SpriteRenderer);
+     * ```
+     */
     disableEntitiesByComponent(componentType: ComponentType): void;
+    /**
+     * Enable all Entities that have a component of the given type
+     * @param componentType The class of the component
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.enableEntitiesByComponent(SpriteRenderer);
+     * ```
+     */
     enableEntitiesByComponent(componentType: ComponentType): void;
+    /**
+     * Adds a component to the entity
+     * @param entity The Entity to which the component will be added
+     * @param componentType The class of the component
+     * @returns The instance of the component
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const spriteRenderer = entityManager.addComponent(entity, SpriteRenderer);
+     * ```
+     */
     addComponent<T extends Component>(entity: Entity, componentType: ComponentType<T>): T;
+    /**
+     * Adds an instance of a component to an entity
+     * @param entity The Entity to which the component will be added
+     * @param component The instance of the component
+     * @returns The instance of the component
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const spriteRenderer = new SpriteRenderer();
+     * entityManager.addComponent(entity, spriteRenderer);
+     * ```
+     */
     addComponent<T extends Component>(entity: Entity, component: T): T;
+    /**
+     * Returns TRUE if the Entity has a component of the given type, otherwise it returns FALSE.
+     * @param entity The entity to verify
+     * @param componentType The class of the component
+     * @returns boolean
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const hasSpriteRenderer = entityManager.hasComponent(entity, SpriteRenderer);
+     * ```
+     */
     hasComponent(entity: Entity, componentType: ComponentType): boolean;
+    /**
+     * Returns the component of the given type belonging to the entity
+     * @param entity The entity
+     * @param componentType The class of the component
+     * @returns The instance of the component
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const spriteRenderer = entityManager.getComponent(entity, SpriteRenderer);
+     * ```
+     */
     getComponent<T extends Component>(entity: Entity, componentType: ComponentType<T>): T;
+    /**
+     * Returns all the component belonging to the entity
+     * @param entity The entity
+     * @returns A collection of component instances
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const components = entityManager.getComponents(entity);
+     * ```
+     */
     getComponents(entity: Entity): Component[];
+    /**
+     * Searches for and returns an entity for the component instance
+     * @param component The component instance
+     * @returns The found Entity
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const entity = entityManager.getEntityForComponent(spriteRenderer);
+     * ```
+     */
     getEntityForComponent(component: Component): Entity;
+    /**
+     * Removes the component instance from its Entity
+     * @param component The component instance
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.removeComponent(spriteRenderer)
+     * ```
+     */
     removeComponent(component: Component): void;
+    /**
+     * Removes a component from the entity according to the given type
+     * @param entity The target entity
+     * @param componentType The component class
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.removeComponent(entity, SriteRenderer)
+     * ```
+     */
     removeComponent(entity: Entity, componentType: ComponentType): void;
+    /**
+     * Returns TRUE if the component is enabled, otherwise it returns FALSE
+     * @param component The component instance
+     * @returns boolean
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.isComponentEnabled(spriteRenderer)
+     * ```
+     */
     isComponentEnabled(component: Component): boolean;
+    /**
+     * Returns TRUE if the component is enabled, otherwise it returns FALSE
+     * @param entity The target entity
+     * @param componentType The component class
+     * @returns boolean
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.isComponentEnabled(entity, SpriteRenderer)
+     * ```
+     */
     isComponentEnabled<T extends Component>(entity: Entity, componentType: ComponentType<T>): boolean;
+    /**
+     * Disables a component instance
+     * @param component The component instance
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.disableComponent(spriteRenderer);
+     * ```
+     */
     disableComponent(component: Component): void;
+    /**
+     * Disables a component by its entity and type
+     * @param entity The target entity
+     * @param componentType The component class
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.disableComponent(entity, SpriteRenderer);
+     * ```
+     */
     disableComponent<T extends Component>(entity: Entity, componentType: ComponentType<T>): void;
+    /**
+     * Enables a component instance
+     * @param component The component instance
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.enableComponent(spriteRenderer);
+     * ```
+     */
     enableComponent(component: Component): void;
+    /**
+     * Enables a component by its entity and type
+     * @param entity The target entity
+     * @param componentType The component class
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * entityManager.enableComponent(entity, SpriteRenderer);
+     * ```
+     */
     enableComponent<T extends Component>(entity: Entity, componentType: ComponentType<T>): void;
+    /**
+     * Performs a search for entities given a component type.\
+     * This method returns a collection of objects of type SearchResult, which has the entity found, and the instance of the component.\
+     * This search can be filtered by passing as a second argument an instance of SearchCriteria, which performs a match between the attributes of the component and the given value.\
+     * The third argument determines if disabled entities or components are included in the search result,\its default value is FALSE.
+     * @param componentType The component class
+     * @param criteria The search criteria
+     * @param includeDisabled TRUE to incluide disabled entities and components, FALSE otherwise
+     * @returns SearchResult
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const searchResult = entityManager.search(SpriteRenderer);
+     * searchResult.forEach(({component, entity}) => {
+     *   // do something with the component and entity
+     * })
+     * ```
+     * @example
+     * ```js
+     * const searchResult = entityManager.search(Enemy, {status: "alive"});
+     * searchResult.forEach(({component, entity}) => {
+     *   // do something with the component and entity
+     * })
+     * ```
+     */
     search<T extends Component>(componentType: ComponentType<T>, criteria?: SearchCriteria, includeDisabled?: boolean): SearchResult<T>[];
+    /**
+     * Performs an entity search given a collection of component types.\
+     * The entities found must have an instance of all the given component types.\
+     * This method returns a collection of Entities.
+     * @param componentTypes A collection of component classes
+     * @returns A collection of entities
+     * @public
+     * @category Core
+     * @example
+     * ```js
+     * const entities = entityManager.searchEntitiesByComponents([Transform, SpriteRenderer, Animator]);
+     * ```
+     */
     searchEntitiesByComponents(componentTypes: ComponentType[]): Entity[];
     private getComponentTypeId;
 }
 
+/**
+ * This interface is used for the creation of system classes. You will have to inject the dependencies you need manully.
+ * @public
+ * @category Core
+ * @example
+ * ```typescript
+ * class PlayerSystem implements System {
+ *   @inject(Symbols.EntityManager) private readonly entityManager: EntityManager;
+ *
+ *   public onUpdate() {
+ *     this.entityManager.search(Player).forEach(({component, entity}) => {
+ *       // do somethng
+ *     });
+ *   }
+ * }
+ * ```
+ */
 interface System {
+    /**
+     * This method is called the first time the system is enabled
+     * @public
+     */
     onCreate?(): void;
+    /**
+     * This method is called when the system is destroyed
+     * @public
+     */
     onDestroy?(): void;
+    /**
+     * This method is called when the system is disabled
+     * @public
+     */
     onDisabled?(): void;
+    /**
+     * This method is called when the system is enabled
+     * @public
+     */
     onEnabled?(): void;
+    /**
+     * This method is called once every frame
+     * @public
+     */
     onUpdate(): void;
 }
+/**
+ * This type represents a system class
+ * @public
+ * @category Core
+ */
 type SystemType<T extends System = System> = {
     new (...args: any[]): T;
 };
+/** @internal */
 type SystemGroup = string | number | symbol;
+/**
+ * The SystemManager manages the systems.\
+ * It provides the necessary methods for reading and writing systems.
+ * @public
+ * @category Core
+ */
 declare class SystemManager {
     private systems;
+    /**
+     * @param systemType The system class
+     * @returns the systen index
+     */
     private findSystemIndex;
+    /**
+     * Adds a new system instance linked to a group
+     * @param system The system instance
+     * @param group The system group
+     * @internal
+     */
     addSystem(system: System, group: SystemGroup): void;
+    /**
+     * Returns TRUE if it has a system of the given type, otherwise it returns FALSE
+     * @param systemType The system class
+     * @returns boolean
+     * @public
+     * @example
+     * ```js
+     * const hasPlayerSystem = systemManager.hasSystem(PlayerSystem);
+     * ```
+     */
     hasSystem(systemType: SystemType): boolean;
+    /**
+     * Returns a system instance for the given type
+     * @param systemType The system class
+     * @returns The system instance
+     * @internal
+     */
     getSystem<T extends System>(systemType: SystemType<T>): T;
+    /**
+     * Enables a system by its type.\
+     * The method `onEnabled` of the system will be called. If the system is enabled for the first time, the method `onCreate` will also be called.
+     * @param systemType The system class
+     * @public
+     * @example
+     * ```js
+     * systemManager.enableSystem(PlayerSystem);
+     * ```
+     */
     enableSystem(systemType: SystemType): void;
+    /**
+     * Disables a system by its type.\
+     * The method `onDisabled` of the system will be called.
+     * @param systemType The system class
+     * @public
+     * @example
+     * ```js
+     * systemManager.disableSystem(PlayerSystem);
+     * ```
+     */
     disableSystem(systemType: SystemType): void;
+    /**
+     * Set the execution priority of a system.
+     * @param systemType The system class
+     * @param position the priority number
+     * @internal
+     */
     setExecutionOrder(systemType: SystemType, position: number): void;
+    /**
+     * Removes a system by its type.
+     * The method `onDestroy` of the system will be called.
+     * @param systemType The system class
+     * @internal
+     */
     removeSystem(systemType: SystemType): void;
+    /**
+     * Call the method onUpdate for systems belonging to the given group
+     * @param group The system group
+     * @internal
+     */
     update(group: SystemGroup): void;
 }
 
 /**
- * Represent a collision. It contains the colliders involved and the resolution data.
- * @category Components
+ * Represent a collision. It contains the colliders involved, the entities, and the resolution data.
+ * @category Collisions
  * @public
  */
 interface Collision {
+    /**
+     * The local collider component
+     * @public
+     */
     localCollider: Collider;
+    /**
+     * The local entity
+     * @public
+     */
     localEntity: Entity;
+    /**
+     * The remote collider component
+     * @public
+     */
     remoteCollider: Collider;
+    /**
+     * The remote collider
+     * @public
+     */
     remoteEntity: Entity;
+    /**
+     * Contains the information about the collision
+     * @public
+     */
     resolution: CollisionResolution;
 }
 
+/**
+ * The CollisionRepository has the necessary methods to perform queries on the current collisions
+ * @public
+ * @category Collisions
+ */
 declare class CollisionRepository {
     private collisions;
+    /**
+     * Searches for and returns a collection of collisions for the given collider
+     * @param collider The local collider
+     * @returns A collection of collisions
+     */
     findCollisionsForCollider(collider: Collider): Collision[];
+    /**
+     * Searches for and returns a collection of collisions for the given collider and layer
+     * @param collider The local collider
+     * @param layer The collision layer
+     * @returns A collection of collisions
+     */
     findCollisionsForColliderAndLayer(collider: Collider, layer: string): Collision[];
+    /**
+     * Returns all the collisions
+     * @public
+     * @returns A collection of collisions
+     */
     findAll(): Collision[];
+    /** @internal */
     persist(collision: Collision): void;
+    /** @internal */
     removeAll(): void;
 }
 
@@ -517,6 +1061,31 @@ declare class CollisionRepository {
  */
 type CollisionMatrix = [string, string][];
 
+/**
+ * Game configuration options
+ * @public
+ * @category Config
+ *  @example
+ * ```js
+ * const gameConfig = {
+ *   containerNode: document.getElementById("app"),
+ *   width: 1920,
+ *   height: 1080,
+ *   debugEnabled: false,
+ *   canvasColor: "#000000",
+ *   physicsFramerate: 180,
+ *   headless: false,
+ *   collisions: {
+ *     collisionMatrix: [
+ *       ["layer1", "layer2"],
+ *       ["layer1", "layer3"],
+ *     ],
+ *     collisionMethod: CollisionMethods.SAT,
+ *     collisionBroadPhaseMethod: BroadPhaseMethods.SpartialGrid,
+ *   }
+ * };
+ * ```
+ */
 interface GameConfig {
     /** HTML element where the game will be created */
     containerNode: HTMLElement;
@@ -585,7 +1154,6 @@ declare class AssetManager {
     /**
      * Loads an image asset
      * @param url The asset URL
-     * @param preloadTexture Creates the texture to be rendered at load time [optional]
      * @returns The HTML Image element created
      */
     loadImage(url: string): HTMLImageElement;
@@ -635,9 +1203,39 @@ declare class AssetManager {
     private createAsset;
 }
 
+/**
+ * This type represents a scene class
+ * @public
+ * @category Core
+ */
 type SceneType<T extends Scene = Scene> = {
     new (entityManager: EntityManager, assetManager: AssetManager): T;
 };
+/**
+ * Base class for all game scenes
+ * @public
+ * @category Core
+ * @example
+ * ```js
+ * class GameScene extends Scene {
+ *   systems = [
+ *     SomeSystem,
+ *     AnotherSystem
+ *   ];
+ *
+ *   loadAssets() {
+ *      this.assetManager.loadImage("image.png");
+ *   }
+ *
+ *   setup() {
+ *     this.entityManager.createEntity([
+ *       SomeComponent,
+ *       AnotherComponent
+ *     ]);
+ *   }
+ * }
+ * ```
+ */
 declare abstract class Scene {
     protected readonly entityManager: EntityManager;
     protected readonly assetManager: AssetManager;
@@ -646,6 +1244,15 @@ declare abstract class Scene {
     loadAssets(): void;
     setup(): void;
 }
+/**
+ * Manges the loading of the scenes.
+ * @public
+ * @category Managers
+ * @example
+ * ```js
+ * this.sceneManager.loadScene("MainScene");
+ * ```
+ */
 declare class SceneManager {
     private readonly systemManager;
     private readonly systemFactory;
@@ -656,6 +1263,7 @@ declare class SceneManager {
     private currentSceneName;
     private sceneNameToBeLoaded;
     private loadingScene;
+    /** @internal */
     constructor(systemManager: SystemManager, systemFactory: SystemFactory, entityManager: EntityManager, assetManager: AssetManager);
     addScene(sceneType: SceneType, name: string, openingScene?: boolean): void;
     loadScene(name: string): void;
@@ -726,7 +1334,7 @@ declare class Game {
     /**
      * Add a new instance to be used as dependency
      *
-     * @param dependency The dependency instance
+     * @param dependencyInstance The dependency instance
      * @param name The name for the dependecy
      */
     addDependencyInstance(dependencyInstance: any, name: DependencyName): void;
@@ -740,14 +1348,20 @@ declare class Game {
     stop(): void;
 }
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface AnimatorOptions {
     animations: Map<string, Animation>;
     animation: string;
     speed: number;
     playing: boolean;
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class Animator {
     animations: Map<string, Animation>;
     animation: string;
@@ -760,7 +1374,10 @@ declare class Animator {
     _currentAnimation: string;
     constructor(options?: Partial<AnimatorOptions>);
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class Animation {
     image: HTMLImageElement | HTMLImageElement[];
     slice: AnimationSlice;
@@ -769,21 +1386,30 @@ declare class Animation {
     loop: boolean;
     constructor(options?: Partial<Animation>);
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 type AnimationSlice = {
     size: Vector2;
     offset: Vector2;
     padding: Vector2;
 };
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface AudioPlayerOptions {
     action: AudioPlayerAction;
     audioSource: HTMLAudioElement;
     loop: boolean;
     volume: number;
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class AudioPlayer {
     action: AudioPlayerAction;
     audioSource: HTMLAudioElement;
@@ -794,9 +1420,16 @@ declare class AudioPlayer {
     _currentAudio: string;
     constructor(options?: Partial<AudioPlayerOptions>);
 }
+/**
+ * @public
+ * @category Components
+ */
 type AudioPlayerAction = "stop" | "play" | "pause";
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface ButtonOptions {
     shape: ButtonShape;
     width: number;
@@ -807,7 +1440,10 @@ interface ButtonOptions {
     onClick: () => void;
     onPressed: () => void;
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class Button {
     /** The shape of the button */
     shape: ButtonShape;
@@ -829,34 +1465,52 @@ declare class Button {
     onPressed: () => void;
     constructor(options?: Partial<ButtonOptions>);
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare enum ButtonShape {
     Rectangle = 0,
     Circumference = 1
 }
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class Children {
     entities: Entity[];
 }
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class Parent {
     entity: Entity;
 }
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledWrapperOptions {
     tilemap: TiledTilemap;
     layerToRender: string;
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class TiledWrapper {
     tilemap: TiledTilemap;
     layerToRender: string;
     constructor(options?: Partial<TiledWrapperOptions>);
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledTilemap {
     width: number;
     height: number;
@@ -870,7 +1524,10 @@ interface TiledTilemap {
     tileheight: number;
     properties?: TiledProperty[];
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledChunk {
     data: number[];
     x: number;
@@ -879,7 +1536,10 @@ interface TiledChunk {
     height: number;
     type?: string;
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledLayer {
     name: string;
     id: number;
@@ -899,7 +1559,10 @@ interface TiledLayer {
     tintcolor?: string;
     properties?: TiledProperty[];
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledObjectLayer {
     draworder: string;
     id: number;
@@ -912,7 +1575,10 @@ interface TiledObjectLayer {
     y: number;
     properties?: TiledProperty[];
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledObject {
     gid: number;
     height: number;
@@ -926,14 +1592,20 @@ interface TiledObject {
     y: number;
     properties?: TiledProperty[];
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TiledProperty {
     name: string;
     type: "int" | "bool" | "float" | "color" | "string";
     value: number | string | boolean;
 }
 
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 interface TransformOptions {
     position: Vector2;
     scale: Vector2;
@@ -943,7 +1615,10 @@ interface TransformOptions {
     localScale: Vector2;
     localRotation: number;
 }
-/** @category Components */
+/**
+ * @public
+ * @category Components
+ */
 declare class Transform {
     /** Position relative to the zero point of the simulated world, or relative to the parent if it has one */
     position: Vector2;
@@ -969,6 +1644,21 @@ declare class Transform {
     constructor(options?: Partial<TransformOptions>);
 }
 
+/**
+ * Configuration object for BallCollider creation
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const ballCollider = new BallCollider({
+ *   radius: 16,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
+ */
 interface BallColliderOptions {
     /** Circumference radius */
     radius: number;
@@ -985,6 +1675,16 @@ interface BallColliderOptions {
  * Circumference shaped collider for 2d collisions.
  * @public
  * @category Components
+ * @example
+ * ```js
+ * const ballCollider = new BallCollider({
+ *   radius: 16,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
  */
 declare class BallCollider implements Collider {
     /** Circumference radius */
@@ -1002,6 +1702,23 @@ declare class BallCollider implements Collider {
     constructor(options?: Partial<BallColliderOptions>);
 }
 
+/**
+ * Configuration object for BoxCollider creation
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const boxCollider = new BoxCollider({
+ *   width: 16,
+ *   height: 16,
+ *   rotation: 0,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
+ */
 interface BoxColliderOptions {
     /** Collision layer*/
     layer: string;
@@ -1022,6 +1739,18 @@ interface BoxColliderOptions {
  * Rectangle shaped collider for 2d collisions.
  * @public
  * @category Components
+ * @example
+ * ```js
+ * const boxCollider = new BoxCollider({
+ *   width: 16,
+ *   height: 16,
+ *   rotation: 0,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
  */
 declare class BoxCollider implements Collider {
     /** Collision layer*/
@@ -1043,6 +1772,22 @@ declare class BoxCollider implements Collider {
     constructor(options?: Partial<BoxColliderOptions>);
 }
 
+/**
+ * Configuration object for EdgeCollider creation
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const edgeCollider = new EdgeCollider({
+ *   vertexModel: [new Vector2(0, 16), new Vector2(16, 16)],
+ *   rotation: 0,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
+ */
 interface EdgeColliderOptions {
     /** Collection of 2d vectors representing the vertices of the collider */
     vertexModel: Vector2[];
@@ -1061,6 +1806,16 @@ interface EdgeColliderOptions {
  * Collider composed of lines defined by its vertices, for 2d collisions.
  * @public
  * @category Components
+ * @example
+ * ```js
+ * const edgeCollider = new EdgeCollider({
+ *   vertexModel: [new Vector2(0, 16), new Vector2(16, 16)],
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
  */
 declare class EdgeCollider implements Collider {
     /** Collection of 2d vectors representing the vertices of the collider */
@@ -1080,6 +1835,22 @@ declare class EdgeCollider implements Collider {
     constructor(options?: Partial<EdgeColliderOptions>);
 }
 
+/**
+ * Configuration object for PolygonCollider creation
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const polygonCollider = new PolygonCollider({
+ *   vertexModel: [new Vector2(0, 16), new Vector2(16, 16), new Vector2(16, 0), new Vector2(0, 0)],
+ *   rotation: 0,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
+ */
 interface PolygonColliderOptions {
     /** Collection of 2d vectors representing the vertices of the collider */
     vertexModel: Vector2[];
@@ -1098,6 +1869,17 @@ interface PolygonColliderOptions {
  * Polygon shaped Collider for 2d collisions. Only convex polygons are allowed.
  * @public
  * @category Components
+ * @example
+ * ```js
+ * const polygonCollider = new PolygonCollider({
+ *   vertexModel: [new Vector2(0, 16), new Vector2(16, 16), new Vector2(16, 0), new Vector2(0, 0)],
+ *   rotation: 0,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
  */
 declare class PolygonCollider implements Collider {
     /** Collection of 2d vectors representing the vertices of the collider */
@@ -1119,7 +1901,7 @@ declare class PolygonCollider implements Collider {
 
 /**
  * The type of the rigid body to create:
- * - Dynamic: This type of body is affected by gravity and velopcity.
+ * - Dynamic: This type of body is affected by gravity and velocity.
  * - Static: This type of body is immovable, is unaffected by velocity and gravity.
  * @category Components
  * @public
@@ -1128,20 +1910,114 @@ declare enum RigidBodyType {
     Dynamic = 0,
     Static = 1
 }
+/**
+ * RigidBody configuration options
+ * @public
+ * @category Components
+ * @example
+ * ```js
+  const rigidBody = new RigidBody({
+    rigidBodyType: RigidBodyType.Dynamic,
+    gravity: 10,
+    velocity: new Vector2(1, 0),
+    acceleration: new Vector2(1, 0)
+  });
+ * ```
+ * @example
+ * ```js
+  const rigidBody = new RigidBody({
+    rigidBodyType: RigidBodyType.Static,
+  });
+ * ```
+ */
 interface RigidBodyOptions {
+    /**
+     * The type of the rigid body to create:
+     * - Dynamic: This type of body is affected by gravity and velocity.
+     * - Static: This type of body is immovable, is unaffected by velocity and gravity.
+     * @public
+     */
     type: RigidBodyType;
+    /**
+     * Velocity applied to the x-axis and y-axis expressed in pixels per second. Only for Dynamic bodies
+     * @public
+     */
     velocity: Vector2;
+    /**
+     * Gravity expressed in pixels per second squared. Only for Dynamic bodies
+     * @public
+     */
     gravity: number;
+    /**
+     * Acceleration expressed in pixels per second squared. Only for Dynamic bodies
+     * @public
+     */
     acceleration: Vector2;
 }
+/**
+ * The RigidBody component puts the entity under simulation of the physics engine, where it will interact with other objects that have a RigidBody.\
+ * There are two types of bodies:
+ * - Dynamic = This type of body is affected by gravity, can be velocity-applied and collides with other rigid bodies.
+ * - Static = This type of body is immovable, no velocity can be applied to it and it is not affected by gravity. It is the body type that consumes the least processing resources.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+  const rigidBody = new RigidBody({
+    rigidBodyType: RigidBodyType.Dynamic,
+    gravity: 10,
+    velocity: new Vector2(1, 0),
+    acceleration: new Vector2(1, 0)
+  });
+ * ```
+ * @example
+ * ```js
+  const rigidBody = new RigidBody({
+    rigidBodyType: RigidBodyType.Static,
+  });
+ * ```
+ */
 declare class RigidBody {
+    /**
+     * The type of the rigid body to create:
+     * - Dynamic: This type of body is affected by gravity and velocity.
+     * - Static: This type of body is immovable, is unaffected by velocity and gravity.
+     * @public
+     */
     type: RigidBodyType;
+    /**
+     * Velocity applied to the x-axis and y-axis expressed in pixels per second. Only for Dynamic bodies
+     * @public
+     */
     velocity: Vector2;
+    /**
+     * Gravity expressed in pixels per second squared. Only for Dynamic bodies
+     * @public
+     */
     gravity: number;
+    /**
+     * Acceleration expressed in pixels per second squared. Only for Dynamic bodies
+     * @public
+     */
     acceleration: Vector2;
     constructor(options?: Partial<RigidBodyOptions>);
 }
 
+/**
+ * Configuration object for TilemapCollider creation
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const tilemapCollider = new TilemapCollider({
+ *   composite: true,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
+ */
 interface TilemapColliderOptions {
     /** Generate colliders that represent the outer lines of the tile map */
     composite: boolean;
@@ -1154,6 +2030,22 @@ interface TilemapColliderOptions {
     /** TRUE if this collider interact with rigid bodies */
     physics: boolean;
 }
+/**
+ * Generates rectangle colliders for the map edge tiles (or lines if composite is TRUE).\
+ * **Limitations:** At the moment, it is not possible to modify the shape of the collider once it has been generated.
+ * @public
+ * @category Components
+ * @example
+ * ```js
+ * const tilemapCollider = new TilemapCollider({
+ *   composite: true,
+ *   offset: new Vector2(),
+ *   layer: "CollisionLayer",
+ *   physics: true,
+ *   ignoreCollisionsWithLayer: ["IgnoredLayer"]
+ * });
+ * ```
+ */
 declare class TilemapCollider implements Collider {
     /** Generate colliders that represent the outer lines of the tile map */
     composite: boolean;
@@ -1218,10 +2110,27 @@ interface ShadowRenderData extends RenderData {
     width: number;
     lights: Light[];
 }
+/**
+ * Represents a light source
+ * @internal
+ * @example
+ * ```js
+ * const light = {
+ *   position: new Vector2(10, 10),
+ *   radius: 32,
+ *   smooth: true,
+ *   intensity: 0.7,
+ * }
+ * ```
+ */
 interface Light {
+    /** The position of the light source */
     position: Vector2;
+    /** The radius of the light source */
     radius: number;
+    /** If it's TRUE the light will gradually disappear away from the origin point, if FALSE the light will be constant over its entire area. */
     smooth: boolean;
+    /** The intensity of the light, between 0 and 1 */
     intensity: number;
 }
 
@@ -1340,6 +2249,11 @@ interface VideoRenderData extends RenderData {
     tintColor?: string;
 }
 
+/**
+ * Default render layer
+ * @public
+ * @category Components
+ */
 declare const defaultRenderLayer = "Default";
 /**
  * @public
@@ -1964,6 +2878,7 @@ declare class GamepadController {
      */
     vibrate(duration?: number, weakMagnitude?: number, strongMagnitude?: number, startDelay?: number): void;
 }
+/** @internal */
 type VibrationInput = {
     duration: number;
     weakMagnitude: number;
@@ -2124,10 +3039,19 @@ declare class TouchScreen {
     interactions: TouchInteraction[];
 }
 
+/**
+ * Manages the input sources: Keyboard, Mouse, Gamepad, TouchScreen.
+ * @public
+ * @category Managers
+ */
 declare class InputManager {
+    /** Manages mouse information. */
     readonly keyboard: Keyboard;
+    /** Manages keyboard information. */
     readonly mouse: Mouse;
+    /** Manages touch screen information. */
     readonly touchScreen: TouchScreen;
+    /** Manages gamepads information. */
     readonly gamepads: GamepadController[];
     constructor();
 }
@@ -2189,6 +3113,20 @@ declare class TimeManager {
     updateForPhysics(time: number): void;
 }
 
+/**
+ * Abstract class which can be used to create Systems.\
+ * It includes the following dependencies: EntityManager, AssetManager, SceneManager, TimeManager, InputManager, CollisionRepository.
+ * @public
+ * @category Core
+ * @example
+ * ```javascript
+ * class SomeSystem extends GameSystem {
+ *   onUpdate() {
+ *     const result = this.entityManager.search(SomeComponent);
+ *   }
+ * }
+ * ```
+ */
 declare abstract class GameSystem implements System {
     protected readonly entityManager: EntityManager;
     protected readonly assetManager: AssetManager;
@@ -2199,10 +3137,48 @@ declare abstract class GameSystem implements System {
     onUpdate(): void;
 }
 
+/**
+ * Decorator to indicate that the target system will run in the game logic loop.
+ * @public
+ * @category Decorators
+ * @example
+ * ```typescript
+ * @gameLogicSystem()
+ * class SomeSystem {
+ * }
+ * ```
+ */
 declare function gameLogicSystem(): (target: SystemType) => void;
+/**
+ * Decorator to indicate that the target system will run in the physics loop.
+ * @public
+ * @category Decorators
+ * @example
+ * ```typescript
+ * @gamePhysicsSystem()
+ * class SomeSystem {
+ * }
+ * ```
+ */
 declare function gamePhysicsSystem(): (target: SystemType) => void;
+/**
+ * Decorator to indicate that the target system will be executed at the begining of the render loop.
+ * @public
+ * @category Decorators
+ * @example
+ * ```typescript
+ * @gamePreRenderSystem()
+ * class SomeSystem {
+ * }
+ * ```
+ */
 declare function gamePreRenderSystem(): (target: SystemType) => void;
 
+/**
+ * Symbols to be used as dependency identifiers
+ * @public
+ * @category Config
+ */
 declare const Symbols: {
     AssetManager: symbol;
     CanvasElement: symbol;
@@ -2215,4 +3191,4 @@ declare const Symbols: {
     TimeManager: symbol;
 };
 
-export { Animation, type AnimationSlice, Animator, type AnimatorOptions, AssetManager, AudioPlayer, type AudioPlayerAction, type AudioPlayerOptions, BallCollider, type BallColliderOptions, BoxCollider, type BoxColliderOptions, BroadPhaseMethods, Button, type ButtonOptions, ButtonShape, Camera, type CameraOptions, Children, type Chunk, Circumference, type Collider, type Collision, type CollisionMatrix, CollisionMethods, CollisionRepository, type CollisionResolution, type Component, type ComponentType, EdgeCollider, type EdgeColliderOptions, type Entity, EntityManager, Game, type GameConfig, GameSystem, GamepadController, InputManager, Keyboard, type Light, LightRenderer, type LightRendererOptions, MaskRenderer, type MaskRendererOptions, MaskShape, Mouse, Parent, Polygon, PolygonCollider, type PolygonColliderOptions, Rectangle, RigidBody, type RigidBodyOptions, RigidBodyType, Scene, SceneManager, type SceneType, type SearchCriteria, type SearchResult, ShadowRenderer, type ShadowRendererOptions, type Shape, type Slice, SpriteRenderer, type SpriteRendererOptions, Symbols, type System, type SystemGroup, SystemManager, type SystemType, TextOrientation, TextRenderer, type TextRendererOptions, type TiledChunk, type TiledLayer, type TiledObject, type TiledObjectLayer, type TiledProperty, type TiledTilemap, TiledWrapper, type TiledWrapperOptions, TilemapCollider, type TilemapColliderOptions, TilemapOrientation, TilemapRenderer, type TilemapRendererOptions, type Tileset, TimeManager, type TouchInteraction, TouchScreen, Transform, type TransformOptions, Vector2, type VibrationInput, VideoRenderer, type VideoRendererOptions, between, clamp, defaultRenderLayer, fixedRound, gameLogicSystem, gamePhysicsSystem, gamePreRenderSystem, inject, injectable, randomFloat, randomInt, range };
+export { Animation, type AnimationSlice, Animator, type AnimatorOptions, AssetManager, AudioPlayer, type AudioPlayerAction, type AudioPlayerOptions, BallCollider, type BallColliderOptions, BoxCollider, type BoxColliderOptions, BroadPhaseMethods, Button, type ButtonOptions, ButtonShape, Camera, type CameraOptions, Children, type Chunk, Circumference, type Collider, type Collision, type CollisionMatrix, CollisionMethods, CollisionRepository, type CollisionResolution, type Component, type ComponentType, type DependencyName, type DependencyType, EdgeCollider, type EdgeColliderOptions, type Entity, EntityManager, Game, type GameConfig, GameSystem, GamepadController, InputManager, Keyboard, LightRenderer, type LightRendererOptions, MaskRenderer, type MaskRendererOptions, MaskShape, Mouse, Parent, Polygon, PolygonCollider, type PolygonColliderOptions, Rectangle, RigidBody, type RigidBodyOptions, RigidBodyType, Scene, SceneManager, type SceneType, type SearchCriteria, type SearchResult, ShadowRenderer, type ShadowRendererOptions, type Shape, type Slice, SpriteRenderer, type SpriteRendererOptions, Symbols, type System, type SystemGroup, SystemManager, type SystemType, TextOrientation, TextRenderer, type TextRendererOptions, type TiledChunk, type TiledLayer, type TiledObject, type TiledObjectLayer, type TiledProperty, type TiledTilemap, TiledWrapper, type TiledWrapperOptions, TilemapCollider, type TilemapColliderOptions, TilemapOrientation, TilemapRenderer, type TilemapRendererOptions, type Tileset, TimeManager, type TouchInteraction, TouchScreen, Transform, type TransformOptions, Vector2, type VibrationInput, VideoRenderer, type VideoRendererOptions, between, clamp, defaultRenderLayer, fixedRound, gameLogicSystem, gamePhysicsSystem, gamePreRenderSystem, inject, injectable, randomFloat, randomInt, range };