@drincs/pixi-vn 0.1.2 → 0.1.3

package/dist/index.d.mts

@@ -0,0 +1,1427 @@
+import * as pixi_js from 'pixi.js';
+import { ContainerOptions, SpriteOptions, TextOptions, Container, Sprite, ContainerEvents, EventEmitter, Texture, TextureSourceLike, Text, UPDATE_PRIORITY, Ticker, TickerCallback, Application, ApplicationOptions } from 'pixi.js';
+
+/**
+ * CanvasEventNamesType is a type that is used to define the event names for the canvas.
+ */
+type CanvasEventNamesType = (string | symbol) extends string | symbol ? (string | symbol) : keyof (string | symbol);
+
+/**
+ * CanvasEvent is a class that is used to create a pixi event, and connect it to a canvas element, with on().
+ * This class should be extended and the fn method should be overridden.
+ * You must use the eventDecorator to register the event in the game.
+ * @example
+ * ```typescript
+ * \@eventDecorator() // this is equivalent to eventDecorator("EventTest")
+ * export class EventTest extends CanvasEvent<CanvasSprite> {
+ *     override fn(event: CanvasEventNamesType, sprite: CanvasSprite): void {
+ *         if (event === 'pointerdown') {
+ *             sprite.scale.x *= 1.25;
+ *             sprite.scale.y *= 1.25;
+ *         }
+ *     }
+ * }
+ * ```
+ */
+declare class CanvasEvent<C> {
+    fn(_event: CanvasEventNamesType, _element: C): void;
+}
+
+/**
+ * StoredClassModel is a abstract class that contains the methods to store a class in the game.
+ * I suggest you extend this class to create your own stored class.
+ * @example
+ * ```typescript
+ * export class CharacterModelBase extends StoredClassModel implements ICharacterModelBase {
+ *     constructor(tag: string, props: ICharacterModelBase) {
+ *         super(tag)
+ *         this.defaultName = props.name
+ *         this.defaultSurname = props.surname
+ *     }
+ *     private defaultName: string = ""
+ *     get name(): string {
+ *         return this.getStorageProperty<string>("name") || this.defaultName
+ *     }
+ *     set name(value: string) {
+ *         this.updateStorage({ ...this, name: value })
+ *     }
+ *     private defaultSurname?: string
+ *     get surname(): string | undefined {
+ *         return this.getStorageProperty<string>("surname") || this.defaultSurname
+ *     }
+ *     set surname(value: string | undefined) {
+ *         this.updateStorage({ ...this, surname: value })
+ *     }
+ * }
+ * ```
+ */
+declare abstract class StoredClassModel {
+    id: string;
+    constructor(id: string);
+    private get nameClass();
+    updateStorage(value: typeof this): void;
+    getStorageProperty<T>(key: string): T | undefined;
+}
+
+interface ICharacterModelBase {
+    name: string;
+    surname?: string;
+    age?: number;
+    icon?: string;
+    color?: string;
+}
+/**
+ * CharacterModelBase is a class that is used to create a character model.
+ * I suggest you extend this class to create your own character models.
+ * You must use the saveCharacter function to save the character in the game.
+ * @example
+ * ```typescript
+ * export const liam = new CharacterModelBase('liam', {
+ *     name: 'Liam',
+ *     surname: 'Smith',
+ *     age: 25,
+ *     icon: "https://pixijs.com/assets/eggHead.png",
+ *     color: "#9e2e12"
+ * });
+ * export const alice = new CharacterModelBase('alice', {
+ *     name: 'Alice',
+ *     surname: 'Smith',
+ *     age: 25,
+ *     icon: "https://pixijs.com/assets/eggHead.png",
+ *     color: "#9e2e12"
+ * });
+ * saveCharacter([liam, alice]);
+ * ```
+ */
+declare class CharacterModelBase extends StoredClassModel implements ICharacterModelBase {
+    constructor(tag: string, props: ICharacterModelBase);
+    private defaultName;
+    get name(): string;
+    set name(value: string);
+    private defaultSurname?;
+    get surname(): string | undefined;
+    set surname(value: string | undefined);
+    private defaultAge?;
+    get age(): number | undefined;
+    set age(value: number | undefined);
+    icon?: string;
+    color?: string;
+}
+
+/**
+ * Base class for all dialogue models. I suggest you extend this class to create your own dialogue models.
+ */
+declare class DialogueModelBase {
+    constructor(text: string, characterTag: string | undefined);
+    /**
+     * The text of the dialogue.
+     */
+    text: string;
+    /**
+     * The tag of the character that is speaking.
+     */
+    characterTag?: string;
+}
+
+/**
+ * StepHistoryData is a string that will be stored in the history of the game.
+ * It is a function converted to string.
+ * if the corresponding function of the step has been changed then StepHistoryData is not equal.
+ */
+type StepHistoryDataType = string;
+
+/**
+ * StepLabel is a function that will be executed as the game continues.
+ */
+type StepLabelType = (() => void | Promise<void>);
+
+/**
+ * Label is a class that contains a list of steps, which will be performed as the game continues.
+ * You must use the labelDecorator to register the label in the game.
+ * For Ren'py this is the equivalent of a label.
+ * @example
+ * ```typescript
+ * \@labelDecorator() // this is equivalent to labelDecorator("StartLabel")
+ * export class StartLabel extends Label {
+ *     override get steps(): StepLabelType[] {
+ *         return [
+ *             () => {
+ *                 GameWindowManager.clear()
+ *                 setDialogue({ character: liam, text: "Which test do you want to perform?" })
+ *                 setMenuOptions([
+ *                     new MenuOptionLabel("Events Test", EventsTestLabel),
+ *                     new MenuOptionLabel("Show Image Test", ShowImageTest),
+ *                 ])
+ *             },
+ *             () => GameStepManager.jumpLabel(StartLabel),
+ *         ]
+ *     }
+ * }
+ * GameStepManager.callLabel(StartLabel)
+ * ```
+ */
+declare class Label {
+    /**
+     * Get the steps of the label.
+     * This class should be extended and the steps method should be overridden.
+     * Every time you update this list will also be updated when the other game versions load.
+     */
+    get steps(): StepLabelType[];
+    /**
+     * Get the corresponding steps number
+     * @param externalSteps
+     * @returns Numer of corresponding steps, for example, if externalSteps is [ABC, DEF, GHI] and the steps of the label is [ABC, GHT], the result will be 1
+     */
+    getCorrespondingStepsNumber(externalSteps: StepHistoryDataType[] | StepLabelType[]): number;
+}
+
+/**
+ * Enumeration of label modes that occurred during the progression of the steps.
+ */
+declare enum LabelRunModeEnum {
+    OpenByCall = "openbycall",
+    OpenByJump = "openbyjump"
+}
+
+/**
+ * MenuOptionLabel is a class that contains a Label and a text that will be displayed in the menu.
+ * @example
+ * ```typescript
+ * new MenuOptionLabel("Events Test", EventsTestLabel)
+ * ```
+ */
+declare class MenuOptionLabel {
+    text: string;
+    label: typeof Label;
+    type: LabelRunModeEnum;
+    constructor(text: string, label: typeof Label, type?: LabelRunModeEnum);
+}
+
+/**
+ * Interface for the canvas base memory
+ */
+interface ICanvasBaseMemory {
+    className: string;
+}
+
+/**
+ * Interface for the canvas container memory
+ */
+interface ICanvasContainerMemory extends ContainerOptions, ICanvasBaseMemory {
+    elements: ICanvasBaseMemory[];
+}
+
+type EventTagType = string;
+
+/**
+ * Interface for texture memory
+ */
+interface ITextureMemory {
+    image: string;
+}
+
+interface ICanvasSpriteBaseMemory extends SpriteOptions, ICanvasBaseMemory {
+    textureImage: ITextureMemory;
+    onEvents: {
+        [name: CanvasEventNamesType]: EventTagType;
+    };
+}
+/**
+ * Interface for the canvas sprite memory
+ */
+interface ICanvasSpriteMemory extends ICanvasSpriteBaseMemory {
+    className: "CanvasSprite";
+}
+
+/**
+ * The memory of the image. It uses for save the state of the image.
+ */
+interface ICanvasImageMemory extends ICanvasSpriteBaseMemory {
+    className: "CanvasImage";
+}
+
+/**
+ * Interface for the canvas text memory
+ */
+interface ICanvasTextMemory extends TextOptions, ICanvasBaseMemory {
+    className: "CanvasText";
+    onEvents: {
+        [name: CanvasEventNamesType]: EventTagType;
+    };
+}
+
+/**
+ * This class is used to create a canvas element to add into a Pixi Application.
+ * You can use GameWindowManager.addCanvasElement() to add this element into the application.
+ * This class should be implemented and the memory method should be overridden.
+ * You must use the canvasElementDecorator to register the canvas in the game.
+ * In Ren'Py is a displayable.
+ * @example
+ * ```typescript
+ * \@canvasElementDecorator() // this is equivalent to canvasElementDecorator("CanvasExample")
+ * export class CanvasExample extends Container implements CanvasBase<ICanvasExampleMemory> {
+ *     get memory(): ICanvasExampleMemory {
+ *         return {
+ *             className: "CanvasExample",
+ *             // ... other properties
+ *         }
+ *     }
+ *     set memory(value: ICanvasExampleMemory) {
+ *         // ... set other properties
+ *     }
+ * }
+ * ```
+ */
+declare class CanvasBase<T2 extends ICanvasBaseMemory> extends Container {
+    /**
+     * This method return the memory of the canvas element.
+     */
+    get memory(): T2;
+    /**
+     * This method set the memory of the canvas element.
+     */
+    set memory(_value: T2);
+}
+
+/**
+ * This class is a extension of the [PIXI.Container class](https://pixijs.com/8.x/examples/basic/container), it has the same properties and methods,
+ * but it has the ability to be saved and loaded by the Pixi'VM library.
+ * @example
+ * ```typescript
+ *  const container = new CanvasContainer();
+ *  GameWindowManager.addCanvasElement(container);
+ *  const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
+ *  for (let i = 0; i < 25; i++)
+ *  {
+ *      const bunny = new CanvasSprite(texture);
+ *      bunny.x = (i % 5) * 40;
+ *      bunny.y = Math.floor(i / 5) * 40;
+ *      container.addChild(bunny);
+ *  }
+ * ```
+ */
+declare class CanvasContainer extends Container implements CanvasBase<ICanvasContainerMemory> {
+    get memory(): ICanvasContainerMemory;
+    set memory(value: ICanvasContainerMemory);
+}
+
+/**
+ * This class is a extension of the [PIXI.Sprite class](https://pixijs.com/8.x/examples/sprite/basic), it has the same properties and methods,
+ * but it has the ability to be saved and loaded by the Pixi'VM library.
+ * @example
+ * ```typescript
+ * const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
+ * const sprite = CanvasSprite.from(texture);
+ *
+ * sprite.anchor.set(0.5);
+ * sprite.x = GameWindowManager.screen.width / 2;
+ * sprite.y = GameWindowManager.screen.height / 2;
+ *
+ * sprite.eventMode = 'static';
+ * sprite.cursor = 'pointer';
+ * sprite.onEvent('pointerdown', EventTest);
+ *
+ * GameWindowManager.addCanvasElement("bunny", sprite);
+ * ```
+ */
+declare class CanvasSprite<Memory extends SpriteOptions & ICanvasBaseMemory = ICanvasSpriteMemory> extends Sprite implements CanvasBase<Memory | ICanvasSpriteMemory> {
+    get memory(): Memory | ICanvasSpriteMemory;
+    set memory(value: ICanvasSpriteMemory);
+    private _onEvents;
+    get onEvents(): {
+        [name: string]: string;
+        [name: symbol]: string;
+    };
+    /**
+     * is same function as on(), but it keeps in memory the children.
+     * @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
+     * @param eventClass The class that extends CanvasEvent.
+     * @returns
+     * @example
+     * ```typescript
+     * \@eventDecorator()
+     * export class EventTest extends CanvasEvent<CanvasSprite> {
+     *     override fn(event: CanvasEventNamesType, sprite: CanvasSprite): void {
+     *         if (event === 'pointerdown') {
+     *             sprite.scale.x *= 1.25;
+     *             sprite.scale.y *= 1.25;
+     *         }
+     *     }
+     * }
+     * ```
+     *
+     * ```typescript
+     * let sprite = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+     * await sprite.load()
+     *
+     * sprite.eventMode = 'static';
+     * sprite.cursor = 'pointer';
+     * sprite.onEvent('pointerdown', EventTest);
+     *
+     * GameWindowManager.addCanvasElement("bunny", sprite);
+     * ```
+     */
+    onEvent<T extends CanvasEventNamesType, T2 extends typeof CanvasEvent<typeof this>>(event: T, eventClass: T2): this;
+    /**
+     * on() does not keep in memory the event class, use onEvent() instead
+     * @deprecated
+     * @private
+     * @param event
+     * @param fn
+     * @param context
+     */
+    on<T extends keyof ContainerEvents | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents & {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>[Extract<T, keyof ContainerEvents | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>]) => void, context?: any): this;
+    static from(source: Texture | TextureSourceLike, skipCache?: boolean): CanvasSprite<any>;
+}
+
+/**
+ * This class is a extension of the CanvasSprite class, it has the same properties and methods,
+ * but it has some features that make texture management easier.
+ * You need to use CanvasImage.load() to show the image in the canvas.
+ * This class is used for functions like addImage, showCanvasImages and showImageWithDisolveEffect.
+ * @example
+ * ```typescript
+ * let alien = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+ * alien.anchor.set(0.5);
+ * alien.x = 100
+ * alien.y = 100
+ * await alien.load()
+ * ```
+ */
+declare class CanvasImage extends CanvasSprite<ICanvasImageMemory> {
+    get memory(): ICanvasImageMemory;
+    set memory(memory: ICanvasImageMemory);
+    imageLink: string;
+    static from(source: Texture | TextureSourceLike, skipCache?: boolean): CanvasImage;
+    /**
+     * Load the image in the canvas.
+     * @returns a promise that resolves when the image is loaded.
+     */
+    load(): Promise<void>;
+}
+
+/**
+ * This class is a extension of the [PIXI.Text class](https://pixijs.com/8.x/examples/text/pixi-text), it has the same properties and methods,
+ * but it has the ability to be saved and loaded by the Pixi'VM library.
+ * @example
+ * ```typescript
+ * const text = new CanvasText();
+ * text.text = "Hello World"
+ * GameWindowManager.addCanvasElement("text", text);
+ * ```
+ */
+declare class CanvasText extends Text implements CanvasBase<ICanvasTextMemory> {
+    get memory(): ICanvasTextMemory;
+    set memory(value: ICanvasTextMemory);
+    private _onEvents;
+    get onEvents(): {
+        [name: string]: string;
+        [name: symbol]: string;
+    };
+    /**
+     * is same function as on(), but it keeps in memory the children.
+     * @param event The event type, e.g., 'click', 'mousedown', 'mouseup', 'pointerdown', etc.
+     * @param eventClass The class that extends CanvasEvent.
+     * @returns
+     * @example
+     * ```typescript
+     * \@eventDecorator()
+     * export class EventTest extends CanvasEvent<CanvasText> {
+     *     override fn(event: CanvasEventNamesType, text: CanvasText): void {
+     *         if (event === 'pointerdown') {
+     *             text.scale.x *= 1.25;
+     *             text.scale.y *= 1.25;
+     *         }
+     *     }
+     * }
+     * ```
+     *
+     * ```typescript
+     * const text = new CanvasText();
+     * text.text = "Hello World"
+     *
+     * text.eventMode = 'static';
+     * text.cursor = 'pointer';
+     * text.onEvent('pointerdown', EventTest);
+     *
+     * GameWindowManager.addCanvasElement("text", text);
+     * ```
+     */
+    onEvent<T extends CanvasEventNamesType, T2 extends typeof CanvasEvent<typeof this>>(event: T, eventClass: T2): this;
+    /**
+     * on() does not keep in memory the event class, use onEvent() instead
+     * @deprecated
+     * @private
+     * @param event
+     * @param fn
+     * @param context
+     */
+    on<T extends keyof ContainerEvents | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents & {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>[Extract<T, keyof ContainerEvents | keyof {
+        [K: symbol]: any;
+        [K: {} & string]: any;
+    }>]) => void, context?: any): this;
+}
+
+interface ITicker<TArgs extends TickerArgsType> {
+    /**
+     * Arguments to pass to the ticker
+     */
+    args: TArgs;
+    /**
+     * Duration in milliseconds
+     */
+    duration?: number;
+    /**
+     * Priority of the ticker
+     */
+    priority?: UPDATE_PRIORITY;
+}
+
+/**
+ * StorageElementType are all the types that can be stored in the storage
+ */
+type StorageElementType = string | number | boolean | object | undefined | null;
+
+type TickerArgsType = {
+    [tag: string]: StorageElementType;
+};
+/**
+ * A class is used to create a ticker element to add into a Pixi Application.
+ * You can use GameWindowManager.addTicker() to add this element into the application.
+ * This class should be extended and the fn method should be overridden.
+ * You must use the tickerDecorator to register the ticker in the game.
+ * In Ren'Py is a transform.
+ * @example
+ * ```typescript
+ * \@tickerDecorator() // this is equivalent to tickerDecorator("TickerRotate")
+ * export class TickerRotate extends TickerBase<{ speed?: number }> {
+ *     override fn(
+ *         t: Ticker,
+ *         args: {
+ *             speed?: number,
+ *         },
+ *         tags: string[]
+ *     ): void {
+ *         let speed = args.speed === undefined ? 0.1 : args.speed
+ *         tags.forEach((tag) => {
+ *                 let element = GameWindowManager.getCanvasElement(tag)
+ *                 if (element && element instanceof Container) {
+ *                     if (clockwise)
+ *                         element.rotation += speed * t.deltaTime
+ *                     else
+ *                         element.rotation -= speed * t.deltaTime
+ *                 }
+ *             })
+ *     }
+ * }
+ * ```
+ */
+declare class TickerBase<TArgs extends TickerArgsType> implements ITicker<TArgs> {
+    constructor(args: TArgs, duration?: number, priority?: UPDATE_PRIORITY);
+    args: TArgs;
+    duration?: number;
+    priority?: UPDATE_PRIORITY;
+    /**
+     * The method that will be called every frame.
+     * This method should be overridden and you can use GameWindowManager.addCanvasElement() to get the canvas element of the canvas, and edit them.
+     * @param t The ticker that is calling this method
+     * @param args The arguments that you passed when you added the ticker
+     * @param tags The tags of the canvas elements that are connected to this ticker
+     */
+    fn(_t: Ticker, _args: TArgs, _tags: string | string[]): void;
+}
+
+/**
+ * A ticker that fades the alpha of the canvas element of the canvas.
+ * @param args The arguments that are passed to the ticker
+ * - speed: The speed of the fade
+ * - type: The type of the fade, default is "hide"
+ * - limit: The limit of the fade, default is 0 for hide and 1 for show
+ * - tagToRemoveAfter?: The tag to remove after the fade is done
+ * - startOnlyIfHaveTexture?: If true, the fade only starts if the canvas element have a texture
+ * @param duration The duration of the ticker
+ * @param priority The priority of the ticker
+ * @example
+ * ```typescript
+ * let bunny = addImage("bunny1", "https://pixijs.com/assets/eggHead.png")
+ * await bunny.load()
+ * GameWindowManager.addCanvasElement("bunny", bunny);
+ * // ...
+ * const ticker = new TickerFadeAlpha({
+ *     speed: 0.01,
+ *     type: "hide",
+ * }),
+ * GameWindowManager.addTicker("bunny", ticker)
+ * ```
+ */
+declare class TickerFadeAlpha extends TickerBase<{
+    speed: number;
+    type?: "hide" | "show";
+    limit?: number;
+    tagToRemoveAfter?: string[] | string;
+    startOnlyIfHaveTexture?: boolean;
+}> {
+    /**
+     * The method that will be called every frame to fade the alpha of the canvas element of the canvas.
+     * @param delta The delta time
+     * @param args The arguments that are passed to the ticker
+     * @param tags The tags of the canvas element that are connected to this ticker
+     */
+    fn(t: Ticker, args: {
+        speed?: number;
+        type?: "hide" | "show";
+        limit?: number;
+        tagToRemoveAfter?: string[] | string;
+        startOnlyIfHaveTexture?: boolean;
+    }, tags: string[]): void;
+}
+
+type TickerProgrationType = ITickerProgrationLinear | ITickerProgrationExponential;
+interface ITickerProgrationLinear {
+    amt: number;
+    limit?: number;
+    type: "linear";
+}
+interface ITickerProgrationExponential {
+    percentage: number;
+    limit?: number;
+    type: "exponential";
+}
+
+/**
+ * A ticker that rotates the canvas element of the canvas.
+ * @param args The arguments that are passed to the ticker
+ * - speed: The speed of the rotation, default is 0.1
+ * - clockwise: The direction of the rotation, default is true
+ * - speedProgression: The progression of the speed
+ * - startOnlyIfHaveTexture?: If true, the rotation only starts if the canvas element have a texture
+ * @param duration The duration of the ticker
+ * @param priority The priority of the ticker
+ * @example
+ * ```typescript
+ * let alien = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
+ * GameWindowManager.addCanvasElement("alien", alien);
+ * const ticker = new TickerRotate({
+ *    speed: 0.1,
+ *    clockwise: true,
+ * }),
+ * GameWindowManager.addTicker("alien", ticker)
+ */
+declare class TickerRotate extends TickerBase<{
+    speed?: number;
+    clockwise?: boolean;
+    speedProgression?: TickerProgrationType;
+    startOnlyIfHaveTexture?: boolean;
+}> {
+    /**
+     * The method that will be called every frame to rotate the canvas element of the canvas.
+     * @param delta The delta time
+     * @param args The arguments that are passed to the ticker
+     * @param tags The tags of the canvas element that are connected to this ticker
+     */
+    fn(t: Ticker, args: {
+        speed?: number;
+        clockwise?: boolean;
+        speedProgression?: TickerProgrationType;
+        startOnlyIfHaveTexture?: boolean;
+    }, tags: string[]): void;
+}
+
+type CanvasElementTagType = string;
+
+/**
+ * Is a decorator that register a canvas element in the game.
+ * @param name Name of the canvas element, by default it will use the class name. If the name is already registered, it will show a warning
+ * @returns
+ */
+declare function canvasElementDecorator(name?: CanvasElementTagType): (target: typeof CanvasBase<any>) => void;
+
+/**
+ * Is a function that saves the character. If the character already exists, it will be overwritten.
+ * @param character is the character to save
+ * @returns
+ * @example
+ * ```typescript
+ * export const liam = new CharacterModelBase('liam', { name: 'Liam'});
+ * export const alice = new CharacterModelBase('alice', { name: 'Alice'});
+ * saveCharacter([liam, alice]);
+ * ```
+ */
+declare function saveCharacter<T extends CharacterModelBase = CharacterModelBase>(character: T | T[]): void;
+/**
+ * is a function that returns the character by the tag
+ * @param tag is the tag of the character
+ * @returns the character
+ * @example
+ * ```typescript
+ * const liam = getCharacterByTag('liam');
+ * ```
+ */
+declare function getCharacterByTag<T extends CharacterModelBase>(tag: string): T | undefined;
+
+/**
+ * Is a decorator that register a event in the game.
+ * Is a required decorator for use the event in the game.
+ * Thanks to this decoration the game has the possibility of updating the events to the latest modification and saving the game.
+ * @param name is th identifier of the event, by default is the name of the class
+ * @returns
+ */
+declare function eventDecorator(name?: EventTagType): (target: typeof CanvasEvent<any>) => void;
+
+/**
+ * LabelTagType is a string containing the name of the label.
+ * It is used to GameStepManager.registeredLabels to get the label class.
+ */
+type LabelTagType = string;
+
+/**
+ * Is a decorator that register a label in the game.
+ * Is a required decorator for use the label in the game.
+ * Thanks to this decoration the game has the possibility of updating the labels to the latest modification and saving the game.
+ * @param name is th identifier of the label, by default is the name of the class
+ * @returns
+ */
+declare function labelDecorator(name?: LabelTagType): (target: typeof Label) => void;
+
+/**
+ * TickerTagType is a string that represents a ticker tag.
+ * It is used to GameWindowManager.tickers to get the ticker class.
+ */
+type TickerTagType = string;
+
+/**
+ * Is a decorator that register a ticker in the game.
+ * Is a required decorator for use the ticker in the game.
+ * Thanks to this decoration the game has the possibility of updating the tickers to the latest modification and saving the game.
+ * @param name is th identifier of the label, by default is the name of the class
+ * @returns
+ */
+declare function tickerDecorator(name?: TickerTagType): (target: typeof TickerBase<any>) => void;
+
+/**
+ * Munu is a type that contains a list of Label that a player can choose from.
+ * For Ren'py this is the equivalent of a menu.
+ */
+type MenuOptionsType = MenuOptionLabel[];
+
+/**
+ * Set the dialogue to be shown in the game
+ * @param text Text of the dialogue
+ * @example
+ * ```typescript
+ * setDialogue("Hello World")
+ * setDialogue({
+ *       character: "characterTag",
+ *       text: "Hello World"
+ * })
+ * ```
+ */
+declare function setDialogue(props: {
+    character: string | CharacterModelBase;
+    text: string;
+} | string): void;
+/**
+ * Get the dialogue to be shown in the game
+ * @returns Dialogue to be shown in the game
+ */
+declare function getDialogue(): DialogueModelBase | undefined;
+/**
+ * Clear the dialogue to be shown in the game
+ */
+declare function clearDialogue(): void;
+/**
+ * Set the options to be shown in the game
+ * @param options Options to be shown in the game
+ * @example
+ * ```typescript
+ * setMenuOptions([
+ *     new MenuOptionLabel("Events Test", EventsTestLabel),
+ *     new MenuOptionLabel("Show Image Test", ShowImageTest),
+ *     new MenuOptionLabel("Ticker Test", TickerTestLabel),
+ *     new MenuOptionLabel("Tinting Test", TintingTestLabel),
+ *     new MenuOptionLabel("Base Canvas Element Test Label", BaseCanvasElementTestLabel)
+ * ])
+ * ```
+ */
+declare function setMenuOptions(options: MenuOptionsType): void;
+/**
+ * Get the options to be shown in the game
+ * @returns Options to be shown in the game
+ */
+declare function getMenuOptions(): MenuOptionsType | undefined;
+/**
+ * Clear the options to be shown in the game
+ */
+declare function clearMenuOptions(): void;
+/**
+ * Get the history of the dialogues
+ * @returns the history of the dialogues
+ */
+declare function getDialogueHistory(): DialogueModelBase[];
+
+/**
+ * Clear all game data. This function is used to reset the game.
+ */
+declare function clearAllGameDatas(): void;
+
+/**
+ * Add a image in the canvas.
+ * Is the same that showImage, but the image is not shown.
+ * If you want to show the image, then you need to use the function CanvasImage.load().
+ * @param tag is the unique tag of the image. You can use this tag to refer to this image
+ * @param imageUrl is the url of the image.
+ * @returns the container of the image.
+ * @example
+ * ```typescript
+ * let alien = addImage("bunny1", "https://pixijs.com/assets/eggHead.png")
+ * await alien.load()
+ * ```
+ */
+declare function addImage(tag: string, imageUrl: string): CanvasImage;
+/**
+ * Show a list of images in the canvas, at the same time.
+ * @param canvasImages is a list of images to show.
+ * @returns the list of images.
+ */
+declare function showCanvasImages(canvasImages: CanvasImage[] | CanvasImage): Promise<CanvasImage[]>;
+/**
+ * Remove a image from the canvas.
+ * @param tag is the unique tag of the image. You can use this tag to refer to this image
+ */
+declare function removeCanvasElement(tag: string | string[]): void;
+/**
+ * Show a image in the canvas with a disolve effect.
+ * Disolve effect is a effect that the image is shown with a fade in.
+ * If exist a image with the same tag, then the image is replaced. And the first image is removed after the effect is done.
+ * @param tag The unique tag of the image. You can use this tag to refer to this image
+ * @param imageUrl The url of the image.
+ * @param args The arguments of the effect
+ * @param duration The duration of the effect
+ * @param priority The priority of the effect
+ * @returns The sprite of the image.
+ */
+declare function showImageWithDisolveEffect(tag: string, imageUrl: string, speed: number, priority?: UPDATE_PRIORITY): Promise<void>;
+
+/**
+ * IClassWithArgsHistory is a class that contains the name of a class and the arguments that were used to create it.
+ */
+interface IClassWithArgsHistory<TArgs extends TickerArgsType> {
+    fn: TickerCallback<any>;
+    className: TickerTagType;
+    args: TArgs;
+    canvasElementTags: string[];
+    priority?: UPDATE_PRIORITY;
+    duration?: number;
+}
+interface IClassWithArgsHistoryForExport<TArgs extends TickerArgsType> {
+    className: TickerTagType;
+    args: TArgs;
+    canvasElementTags: string[];
+    priority?: UPDATE_PRIORITY;
+    duration?: number;
+}
+
+/**
+ * Interface exported canvas
+ */
+interface ExportedCanvas {
+    currentTickers: IClassWithArgsHistoryForExport<any>[];
+    currentElements: {
+        [tag: string]: ICanvasBaseMemory;
+    };
+    childrenTagsOrder: string[];
+}
+
+/**
+ * Interface exported storage data
+ */
+interface ExportedStorage {
+    storage: {
+        [key: string]: StorageElementType;
+    };
+    stepOidUsedList: string[];
+}
+
+interface IOpenedLabel {
+    label: LabelTagType;
+    currentStepIndex: number;
+}
+
+/**
+ * IHistoryStep is a interface that contains:
+ * - the browser path that occurred during the progression of the steps.
+ * - the storage that occurred during the progression of the steps.
+ * - the step data.
+ * - the canvas that occurred during the progression of the steps.
+ */
+interface IHistoryStep {
+    path: string;
+    storage: ExportedStorage;
+    stepSha1: StepHistoryDataType;
+    stepIndex: number;
+    canvas: ExportedCanvas;
+    openedLabels: IOpenedLabel[];
+}
+
+/**
+ * Interface exported step data
+ */
+interface ExportedStep {
+    stepsHistory: IHistoryStep[];
+    openedLabels: IOpenedLabel[];
+}
+
+interface ISaveData {
+    version: string;
+    stepData: ExportedStep;
+    storageData: ExportedStorage;
+    canvasData: ExportedCanvas;
+    path: string;
+}
+
+/**
+ * Get the save data
+ * @returns The save data
+ */
+declare function getSaveData(): ISaveData;
+/**
+ * Get the save data as a JSON string
+ * @returns The save data as a JSON string
+ * @example
+ * ```typescript
+ * export function saveGame() {
+ *     const jsonString = getSaveJson()
+ *     const blob = new Blob([jsonString], { type: "application/json" });
+ *     const url = URL.createObjectURL(blob);
+ *     const a = document.createElement('a');
+ *     a.href = url;
+ *     a.download = "save.json";
+ *     a.click();
+ * }
+ * ```
+ */
+declare function getSaveJson(): string;
+/**
+ * Load the save data
+ * @param data The save data
+ * @param navigate The function to navigate to a path
+ */
+declare function loadSave(data: ISaveData, navigate: (path: string) => void): void;
+/**
+ * Load the save data from a JSON string
+ * @param dataString The save data as a JSON string
+ * @param navigate The function to navigate to a path
+ * @example
+ * ```typescript
+ * export function loadGameSave(navigate: (path: string) => void, afterLoad?: () => void) {
+ *     // load the save data from a JSON file
+ *     const input = document.createElement('input');
+ *     input.type = 'file';
+ *     input.accept = 'application/json';
+ *     input.onchange = (e) => {
+ *         const file = (e.target as HTMLInputElement).files?.[0];
+ *         if (file) {
+ *             const reader = new FileReader();
+ *             reader.onload = (e) => {
+ *                 const jsonString = e.target?.result as string;
+ *                 // load the save data from the JSON string
+ *                 loadSaveJsonString(jsonString, navigate);
+ *                 afterLoad && afterLoad();
+ *             };
+ *             reader.readAsText(file);
+ *         }
+ *     };
+ *     input.click();
+ * }
+ * ```
+ */
+declare function loadSaveJsonString(dataString: string, navigate: (path: string) => void): void;
+
+/**
+ * Get a texture from a url.
+ * @param imageUrl is the url of the image.
+ * @returns the texture of the image, or a text with the error.
+ */
+declare function getTexture(imageUrl: string): Promise<Texture | void>;
+
+declare const PauseValueType = "Pause";
+type PauseType = {
+    type: typeof PauseValueType;
+    duration: number;
+};
+declare function Pause(duration: number): PauseType;
+
+type RepeatType = "Repeat";
+declare const Repeat: RepeatType;
+
+interface ITickersStep<TArgs extends TickerArgsType> extends ITicker<TArgs> {
+    /**
+     * Ticker class name
+     */
+    ticker: string;
+    /**
+     * Duration in milliseconds
+     */
+    duration: number;
+}
+/**
+ * The steps of the tickers
+ */
+interface ITickersSteps {
+    /**
+     * The step number
+     */
+    currentStepNumber: number;
+    /**
+     * The steps of the tickers
+     */
+    steps: (ITickersStep<any> | RepeatType | PauseType)[];
+}
+
+/**
+ * GameHistoryManager is a class that contains the history of the game.
+ */
+declare class GameStepManager {
+    private constructor();
+    /**
+     * stepHistory is a list of label events and steps that occurred during the progression of the steps.
+     */
+    private static _stepsHistory;
+    static get stepsHistory(): IHistoryStep[];
+    static get lastStepIndex(): number;
+    private static _openedLabels;
+    static get openedLabels(): IOpenedLabel[];
+    /**
+     * currentLabel is the current label that occurred during the progression of the steps.
+     */
+    private static get currentLabel();
+    /**
+     * currentLabelStepIndex is the current step index of the current label that occurred during the progression of the steps.
+     */
+    private static get currentLabelStepIndex();
+    /**
+     * lastHistoryStep is the last history step that occurred during the progression of the steps.
+     */
+    private static get lastHistoryStep();
+    /**
+     * Add a label to the history.
+     * @param label The label to add to the history.
+     */
+    private static addStepHistory;
+    /**
+     * Add a label to the history.
+     * @param label The label to add to the history.
+     */
+    private static pushNewLabel;
+    /**
+     * Close the current label and add it to the history.
+     * @returns
+     */
+    private static closeLabel;
+    /**
+     * Close all labels and add them to the history.
+     */
+    private static closeAllLabels;
+    /**
+     * Increase the current step index of the current label.
+     */
+    private static increaseCurrentStepIndex;
+    /**
+     * Execute the next step and add it to the history.
+     * @returns
+     * @example
+     * ```typescript
+     *     function nextOnClick() {
+     *     setLoading(true)
+     *     GameStepManager.runNextStep()
+     *         .then(() => {
+     *             setUpdate((p) => p + 1)
+     *             setLoading(false)
+     *         })
+     *         .catch((e) => {
+     *             setLoading(false)
+     *             console.error(e)
+     *         })
+     * }
+     * ```
+     */
+    static runNextStep(): Promise<void>;
+    /**
+     * Execute the current step and add it to the history.
+     * @returns
+     */
+    private static runCurrentStep;
+    /**
+     * Execute the label and add it to the history.
+     * Is a call function in Ren'Py.
+     * @param label The label to execute.
+     * @returns
+     * @example
+     * ```typescript
+     * GameStepManager.callLabel(StartLabel)
+     * ```
+     */
+    static callLabel(label: typeof Label | Label): Promise<void>;
+    /**
+     * Execute the label, close all labels and add them to the history.
+     * Is a jump function in Ren'Py.
+     * @param label
+     * @returns
+     * @example
+     * ```typescript
+     * GameStepManager.jumpLabel(StartLabel)
+     * ```
+     */
+    static jumpLabel(label: typeof Label | Label): Promise<void>;
+    /**
+     * Go back to the last step and add it to the history.
+     * @param navigate The navigate function.
+     * @param steps The number of steps to go back.
+     * @returns
+     * @example
+     * ```typescript
+     * export function goBack(navigate: (path: string) => void, afterBack?: () => void) {
+     *     GameStepManager.goBack(navigate)
+     *     afterBack && afterBack()
+     * }
+     * ```
+     */
+    static goBack(navigate: (path: string) => void, steps?: number): void;
+    private static goBackInstrnal;
+    /**
+     * Add a label to the history.
+     */
+    static clear(): void;
+    /**
+     * Export the history to a JSON string.
+     * @returns The history in a JSON string.
+     */
+    static exportJson(): string;
+    /**
+     * Export the history to an object.
+     * @returns The history in an object.
+     */
+    static export(): ExportedStep;
+    /**
+     * Import the history from a JSON string.
+     * @param dataString The history in a JSON string.
+     */
+    static importJson(dataString: string): void;
+    /**
+     * Import the history from an object.
+     * @param data The history in an object.
+     */
+    static import(data: object): void;
+}
+
+declare class GameStorageManager {
+    private static oidsUsed;
+    private static storage;
+    private constructor();
+    static get keysSystem(): {
+        CURRENT_DIALOGUE_MEMORY_KEY: string;
+        LAST_DIALOGUE_ADDED_IN_STEP_MEMORY_KEY: string;
+        CURRENT_MENU_OPTIONS_MEMORY_KEY: string;
+    };
+    /**
+     * Get a new oid that is not used yet
+     * @returns A new oid that is not used yet
+     */
+    static getNewOid(): string;
+    /**
+     * Set a variable in the storage
+     * @param key The key of the variable
+     * @param value The value of the variable. If undefined, the variable will be removed
+     * @returns
+     */
+    static setVariable(key: string, value: StorageElementType): void;
+    /**
+     * Get a variable from the storage
+     * @param key The key of the variable
+     * @returns The value of the variable. If the variable does not exist, it will return undefined
+     */
+    static getVariable<T extends StorageElementType>(key: string): T | undefined;
+    /**
+     * Remove a variable from the storage
+     * @param key The key of the variable
+     * @returns
+     */
+    static removeVariable(key: string): void;
+    /**
+     * Clear the storage and the oidsUsed
+     * @returns
+     */
+    static clear(): void;
+    static exportJson(): string;
+    static export(): ExportedStorage;
+    static importJson(dataString: string): void;
+    static import(data: object): void;
+}
+
+/**
+ * This class is responsible for managing the canvas, the tickers, the events, and the window size and the children of the window.
+ */
+declare class GameWindowManager {
+    private constructor();
+    private static _app;
+    /**
+     * The PIXI Application instance.
+     * It not recommended to use this property directly.
+     */
+    static get app(): Application<pixi_js.Renderer>;
+    private static _isInitialized;
+    /**
+     * If the manager is initialized.
+     */
+    static get isInitialized(): boolean;
+    /**
+     * This is the div that have same size of the canvas.
+     * This is useful to put interface elements.
+     * You can use React or other framework to put elements in this div.
+     */
+    static htmlLayout: HTMLElement;
+    static canvasWidth: number;
+    static canvasHeight: number;
+    static get screen(): pixi_js.Rectangle;
+    /**
+     * Initialize the PIXI Application and the interface div.
+     * This method should be called before any other method.
+     * @param element The html element where I will put the canvas. Example: document.body
+     * @param width The width of the canvas
+     * @param height The height of the canvas
+     * @param options The options of PIXI Application
+     * @example
+     * ```typescript
+     * const body = document.body
+     * if (!body) {
+     *     throw new Error('body element not found')
+     * }
+     * await GameWindowManager.initialize(body, 1920, 1080, {
+     *     backgroundColor: "#303030"
+     * })
+     * ```
+     */
+    static initialize(element: HTMLElement, width: number, height: number, options?: Partial<ApplicationOptions>): Promise<void>;
+    /**
+     * Add the canvas into a html element.
+     * @param element it is the html element where I will put the canvas. Example: document.body
+     */
+    static addCanvasIntoElement(element: HTMLElement): void;
+    /**
+     * Initialize the interface div and add it into a html element.
+     * @param element it is the html element where I will put the interface div. Example: document.getElementById('root')
+     * @example
+     * ```typescript
+     * const root = document.getElementById('root')
+     * if (!root) {
+     *     throw new Error('root element not found')
+     * }
+     * GameWindowManager.initializeHTMLLayout(root)
+     * const reactRoot = createRoot(GameWindowManager.htmlLayout)
+     * reactRoot.render(
+     *     <App />
+     * )
+     * ```
+     */
+    static initializeHTMLLayout(element: HTMLElement): void;
+    /**
+     * This method returns the scale of the screen.
+     */
+    static get screenScale(): number;
+    /**
+     * This method returns the width of the screen enlarged by the scale.
+     */
+    static get screenWidth(): number;
+    /**
+     * This method returns the height of the screen enlarged by the scale.
+     */
+    static get screenHeight(): number;
+    /**
+     * This method returns the horizontal margin of the screen.
+     */
+    static get horizontalMargin(): number;
+    /**
+     * This method returns the vertical margin of the screen.
+     */
+    static get verticalMargin(): number;
+    /**
+     * This method is called when the screen is resized.
+     */
+    private static resize;
+    /**
+     * This is a dictionary that contains all Canvas Elements of Canvas, currently.
+     */
+    static get currentCanvasElements(): {
+        [tag: string]: CanvasBase<any>;
+    };
+    private static _children;
+    /**
+     * The order of the children tags.
+     */
+    private static childrenTagsOrder;
+    /**
+     * Add a canvas element to the canvas.
+     * If there is a canvas element with the same tag, it will be removed.
+     * @param tag The tag of the canvas element.
+     * @param canvasElement The canvas elements to be added.
+     * @example
+     * ```typescript
+     * const texture = await Assets.load('https://pixijs.com/assets/bunny.png');
+     * const sprite = CanvasSprite.from(texture);
+     * GameWindowManager.addCanvasElement("bunny", sprite);
+     * ```
+     */
+    static addCanvasElement(tag: string, canvasElement: CanvasBase<any>): void;
+    /**
+     * Remove a canvas element from the canvas.
+     * And remove all tickers that are not connected to any canvas element.
+     * @param tag The tag of the canvas element to be removed.
+     * @returns
+     * @example
+     * ```typescript
+     * GameWindowManager.removeCanvasElement("bunny");
+     * ```
+     */
+    static removeCanvasElement(tag: string | string[]): void;
+    /**
+     * Get a canvas element by the tag.
+     * @param tag The tag of the canvas element.
+     * @returns The canvas element.
+     * @example
+     * ```typescript
+     * const sprite = GameWindowManager.getCanvasElement<CanvasSprite>("bunny");
+     * ```
+     */
+    static getCanvasElement<T extends CanvasBase<any>>(tag: string): T | undefined;
+    /**
+     * Check if a DisplayObject is on the canvas.
+     * @param pixiElement The DisplayObject to be checked.
+     * @returns If the DisplayObject is on the canvas.
+     */
+    static canvasElementIsOnCanvas<T extends Container>(pixiElement: T): boolean;
+    /**
+     * Remove all canvas elements from the canvas.
+     * And remove all tickers that are not connected to any canvas element.
+     */
+    static removeCanvasElements(): void;
+    /**
+     * Edit the tag of a canvas element.
+     * @param oldTag The old tag of the canvas element.
+     * @param newTag The new tag of the canvas element.
+     */
+    static editTagCanvasElement(oldTag: string, newTag: string): void;
+    /** Edit Tickers Methods */
+    /**
+     * Currently tickers that are running.
+     */
+    static get currentTickers(): IClassWithArgsHistory<any>[];
+    private static _currentTickers;
+    /**
+     * The steps of the tickers
+     */
+    static get currentTickersSteps(): {
+        [tag: string]: ITickersSteps;
+    };
+    private static _currentTickersSteps;
+    static currentTickersTimeouts: {
+        [timeout: string]: {
+            tags: string[];
+            ticker: string;
+        };
+    };
+    /**
+     * Run a ticker.
+     * @param canvasEslementTag The tag of the canvas element that will use the ticker.
+     * @param ticker The ticker class to be run.
+     * @param args The arguments to be used in the ticker.
+     * @param duration The time to be used in the ticker. This number is in milliseconds. If it is undefined, the ticker will run forever.
+     * @param priority The priority to be used in the ticker.
+     * @returns
+     * @example
+     * ```typescript
+     * GameWindowManager.addTicker("alien", new TickerRotate({ speed: 0.2 }))
+     * ```
+     */
+    static addTicker<TArgs extends TickerArgsType>(canvasElementTag: string | string[], ticker: TickerBase<TArgs>): void;
+    private static pushTicker;
+    /**
+     * Run a sequence of tickers.
+     * @param tag The tag of canvas element that will use the tickers.
+     * @param steps The steps of the tickers.
+     * @returns
+     * @example
+     * ```typescript
+     * GameWindowManager.addTickersSteps("alien", [
+     *     new TickerRotate({ speed: 0.1, clockwise: true }, 2000),
+     *     Pause(500),
+     *     new TickerRotate({ speed: 0.2, clockwise: false }, 2000),
+     *     Repeat,
+     * ])
+     * ```
+     */
+    static addTickersSteps<TArgs extends TickerArgsType>(tag: string, steps: (ITicker<TArgs> | RepeatType | PauseType)[]): void;
+    private static runTickersSteps;
+    private static nextTickerStep;
+    /**
+     * Remove a connection between a canvas element and a ticker.
+     * And remove the ticker if there is no canvas element connected to it.
+     * @param tag The tag of the canvas element that will use the ticker.
+     * @param ticker The ticker class to be removed.
+     * @example
+     * ```typescript
+     * GameWindowManager.removeAssociationBetweenTickerCanvasElement("alien", TickerRotate)
+     * ```
+     */
+    static removeAssociationBetweenTickerCanvasElement(tag: string | string[], ticker: typeof TickerBase<any> | TickerBase<any>): void;
+    /**
+     * Remove all tickers that are not connected to any existing canvas element.
+     */
+    private static removeTickersWithoutAssociatedCanvasElement;
+    private static addTickerTimeoutInfo;
+    private static removeTickerTimeoutInfo;
+    /**
+     * Remove all tickers from the canvas.
+     */
+    static removeTickers(): void;
+    /**
+     * Clear the canvas and the tickers.
+     */
+    static clear(): void;
+    /**
+     * Export the canvas and the tickers to a JSON string.
+     * @returns The JSON string.
+     */
+    static exportJson(): string;
+    /**
+     * Export the canvas and the tickers to an object.
+     * @returns The object.
+     */
+    static export(): ExportedCanvas;
+    /**
+     * Import the canvas and the tickers from a JSON string.
+     * @param dataString The JSON string.
+     */
+    static importJson(dataString: string): void;
+    /**
+     * Import the canvas and the tickers from an object.
+     * @param data The object.
+     */
+    static import(data: object): void;
+}
+
+export { CanvasBase, CanvasContainer, CanvasEvent, type CanvasEventNamesType, CanvasImage, CanvasSprite, CanvasText, CharacterModelBase, DialogueModelBase, type ExportedCanvas, type ExportedStep, type ExportedStorage, GameStepManager, GameStorageManager, GameWindowManager, type ICanvasBaseMemory, type ICanvasContainerMemory, type ICanvasImageMemory, type ICanvasSpriteBaseMemory, type ICanvasSpriteMemory, type ICanvasTextMemory as ICanvasTextTextMemory, type IClassWithArgsHistory, type IClassWithArgsHistoryForExport, type IHistoryStep, type IOpenedLabel, type ISaveData, type ITextureMemory, type ITicker, type ITickersSteps, Label, LabelRunModeEnum, MenuOptionLabel, type MenuOptionsType, Pause, type PauseType, PauseValueType, Repeat, type RepeatType, type StepLabelType, type StorageElementType, StoredClassModel, TickerBase, TickerFadeAlpha, type TickerProgrationType, TickerRotate, addImage, canvasElementDecorator, clearAllGameDatas, clearDialogue, clearMenuOptions, eventDecorator, getCharacterByTag, getDialogue, getDialogueHistory, getMenuOptions, getSaveData, getSaveJson, getTexture, labelDecorator, loadSave, loadSaveJsonString, removeCanvasElement, saveCharacter, setDialogue, setMenuOptions, showCanvasImages, showImageWithDisolveEffect, tickerDecorator };