@drincs/pixi-vn 0.4.7 → 0.4.8

package/dist/index.d.mts

@@ -1,1774 +1,64 @@
-import * as pixi_js from 'pixi.js';
-import { ContainerOptions, SpriteOptions, TextOptions, Container, Sprite, ContainerEvents, ContainerChild, EventEmitter, Texture, TextureSourceLike, Text, UPDATE_PRIORITY, Ticker, TickerCallback, Application, ApplicationOptions } from 'pixi.js';
 export { Assets } from 'pixi.js';
-import deepDiff from 'deep-diff';
-
-/**
- * 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 CharacterBaseModel extends StoredClassModel implements CharacterBaseModelProps {
- *     constructor(id: string, props: CharacterBaseModelProps) {
- *         super("___character___", id)
- *         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.setStorageProperty<string>("name", value)
- *     }
- *     private defaultSurname?: string
- *     get surname(): string | undefined {
- *         return this.getStorageProperty<string>("surname") || this.defaultSurname
- *     }
- *     set surname(value: string | undefined) {
- *         this.setStorageProperty<string>("surname", value)
- *     }
- * }
- * ```
- */
-declare class StoredClassModel {
-    /**
-     * @param categoryId The id of the category. For example if you are storing a character class, you can use "characters" as categoryId. so all instances of the character class will be stored in the "characters" category.
-     * @param id The id of instance of the class. This id must be unique for the category.
-     */
-    constructor(categoryId: string, id: string);
-    private _id;
-    /**
-     * Is id of the stored class. is unique for this class.
-     */
-    get id(): string;
-    private categoryId;
-    /**
-     * Update a property in the storage.
-     * @param propertyName The name of the property to set.
-     * @param value The value to set. If is undefined, the property will be removed from the storage.
-     */
-    setStorageProperty<T>(propertyName: string, value: T | undefined): void;
-    /**
-     * Get a property from the storage.
-     * @param propertyName The name of the property to get.
-     * @returns The value of the property. If the property is not found, returns undefined.
-     */
-    getStorageProperty<T>(propertyName: string): T | undefined;
-}
-
-/**
- * CharacterBaseModelProps is an interface that is used to create a character model.
- */
-interface CharacterBaseModelProps {
-    /**
-     * The name of the character.
-     */
-    name: string;
-    /**
-     * The surname of the character.
-     */
-    surname?: string;
-    /**
-     * The age of the character.
-     */
-    age?: number;
-    /**
-     * The icon of the character.
-     */
-    icon?: string;
-    /**
-     * The color of the character.
-     */
-    color?: string;
-}
-/**
- * CharacterBaseModel 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 CharacterBaseModel('liam', {
- *     name: 'Liam',
- *     surname: 'Smith',
- *     age: 25,
- *     icon: "https://pixijs.com/assets/eggHead.png",
- *     color: "#9e2e12"
- * });
- * export const alice = new CharacterBaseModel('alice', {
- *     name: 'Alice',
- *     surname: 'Smith',
- *     age: 25,
- *     icon: "https://pixijs.com/assets/eggHead.png",
- *     color: "#9e2e12"
- * });
- * saveCharacter([liam, alice]);
- * ```
- */
-declare class CharacterBaseModel extends StoredClassModel implements CharacterBaseModelProps {
-    /**
-     * @param id The id of the character.
-     * @param props The properties of the character.
-     */
-    constructor(id: string, props: CharacterBaseModelProps);
-    private defaultName;
-    /***
-     * The name of the character.
-     * If you set undefined, it will return the default name.
-     */
-    get name(): string;
-    set name(value: string | undefined);
-    private defaultSurname?;
-    /**
-     * The surname of the character.
-     * If you set undefined, it will return the default surname.
-     */
-    get surname(): string | undefined;
-    set surname(value: string | undefined);
-    private defaultAge?;
-    /**
-     * The age of the character.
-     * If you set undefined, it will return the default age.
-     */
-    get age(): number | undefined;
-    set age(value: number | undefined);
-    private _icon?;
-    /**
-     * The icon of the character.
-     */
-    get icon(): string | undefined;
-    private _color?;
-    /**
-     * The color of the character.
-     */
-    get color(): string | undefined;
-}
-
-/**
- * Enumeration of label modes that occurred during the progression of the steps.
- */
-declare enum LabelRunModeEnum {
-    OpenByCall = "openbycall",
-    OpenByJump = "openbyjump"
-}
-
-/**
- * is a string containing the name of the label.
- * It is used to GameStepManager.registeredLabels to get the label class.
- */
-type LabelIdType = 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;
-
-/**
- * StepLabelPropsType is the type of the props that will be passed to the StepLabel.
- * You can override this interface to add your own props.
- * @example
- * ```typescript
- * declare module '@drincs/pixi-vn/dist' {
- *     navigate: (route: string) => void
- * }
- * ```
- */
-interface StepLabelProps {
-    [key: string]: any;
-}
-/**
- * StepLabelResultType is the return type of the StepLabel function.
- * It can be useful for returning to the information calling function to perform other operations that cannot be performed within the StepLabel.
- * You can override this interface to add your own return types.
- * @example
- * ```typescript
- * declare module '@drincs/pixi-vn/dist' {
- *     newRoute: string
- * }
- * ```
- */
-interface StepLabelResult {
-    [key: string]: any;
-}
-type StepLabelResultType = StepLabelResult | void;
-type StepLabelPropsType = StepLabelProps;
-/**
- * StepLabel is a function that will be executed as the game continues.
- */
-type StepLabelType = ((props: StepLabelPropsType) => StepLabelResultType | Promise<StepLabelResultType>);
-
-/**
- * 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?" })
- *                 setChoiceMenuOptions([
- *                     new ChoiceMenuOptionLabel("Events Test", EventsTestLabel),
- *                     new ChoiceMenuOptionLabel("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;
-}
-
-/**
- * ChoiceMenuOptionLabel is a class that contains a Label and a text that will be displayed in the menu.
- * @example
- * ```typescript
- * new ChoiceMenuOptionLabel("Events Test", EventsTestLabel)
- * ```
- */
-declare class ChoiceMenuOptionLabel {
-    /**
-     * Text to be displayed in the menu
-     */
-    text: string;
-    /**
-     * Label to be opened when the option is selected
-     */
-    label: typeof Label;
-    /**
-     * Type of the label to be opened
-     */
-    type: LabelRunModeEnum;
-    /**
-     * @param text Text to be displayed in the menu
-     * @param label Label to be opened when the option is selected
-     * @param type Type of the label to be opened
-     */
-    constructor(text: string, label: typeof Label, type?: LabelRunModeEnum);
-}
-type IStoratedChoiceMenuOptionLabel = {
-    text: string;
-    label: LabelIdType;
-    type: LabelRunModeEnum;
-};
-
-/**
- * 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 ChoiceMenuOptionsType = ChoiceMenuOptionLabel[];
-
-declare const PauseValueType = "Pause";
-type PauseType = {
-    type: typeof PauseValueType;
-    duration: number;
-};
-declare function Pause(duration: number): PauseType;
-
-type RepeatType = "Repeat";
-declare const Repeat: RepeatType;
-
-type StorageElementPrimaryType = string | number | boolean | undefined | null | StorageElementPrimaryType[];
-type StorageElementInternalType = StorageElementPrimaryType | Record<string | number | symbol, StorageElementPrimaryType> | StorageElementInternalType[];
-/**
- * StorageElementType are all the types that can be stored in the storage
- */
-type StorageElementType = StorageElementInternalType | Record<string | number | symbol, StorageElementInternalType> | {
-    [key: string | number | symbol]: StorageElementType;
-};
-
-type DialogueData = {
-    /**
-     * The text of the dialogue.
-     */
-    text: string;
-    /**
-     * The id of the character that is speaking.
-     */
-    characterId?: string;
-    /**
-     * Other parameters that can be stored in the dialogue.
-     */
-    oltherParams?: Record<string | number | symbol, StorageElementType>;
-};
-/**
- * Base class for all dialogue models.
- * You can extend this class, but it is not reccomended. You can use the oltherParams property to store any other data you need.
- * @example
- * ```typescript
- * setDialogue(new DialogueBaseModel("Hello World", character))
- * ```
- */
-declare class DialogueBaseModel<TCharacter extends CharacterBaseModel = CharacterBaseModel> implements DialogueData {
-    /**
-     * @param text The text of the dialogue.
-     * @param character The id of the character that is speaking.
-     * @param oltherParams Other parameters that can be stored in the dialogue.
-     */
-    constructor(text: string | DialogueData, character?: string | TCharacter, oltherParams?: {
-        [key: string]: StorageElementType;
-    });
-    /**
-     * The text of the dialogue.
-     */
-    text: string;
-    /**
-     * The id of the character that is speaking.
-     */
-    characterId?: string;
-    /**
-     * Other parameters that can be stored in the dialogue.
-     */
-    oltherParams: {
-        [key: string]: StorageElementType;
-    };
-    /**
-     * Export the dialogue to a DialogueBaseData object.
-     *
-     * @returns The data of the dialogue.
-     */
-    export(): DialogueData;
-}
-
-/**
- * Interface for the canvas base memory
- */
-interface ICanvasBaseMemory {
-    className: string;
-}
-
-/**
- * Interface for the canvas container memory
- */
-interface ICanvasContainerMemory extends ContainerOptions, ICanvasBaseMemory {
-    elements: ICanvasBaseMemory[];
-}
-
-type EventIdType = string;
-
-/**
- * Interface for texture memory
- */
-interface ITextureMemory {
-    image: string;
-}
-
-interface ICanvasSpriteBaseMemory extends SpriteOptions, ICanvasBaseMemory {
-    textureImage: ITextureMemory;
-    onEvents: {
-        [name: CanvasEventNamesType]: EventIdType;
-    };
-}
-/**
- * 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]: EventIdType;
-    };
-}
-
-/**
- * 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'VN 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'VN 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<ContainerChild> | keyof {
-        [K: symbol]: any;
-        [K: {} & string]: any;
-    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents<ContainerChild> & {
-        [K: symbol]: any;
-        [K: {} & string]: any;
-    }>[Extract<T, keyof ContainerEvents<ContainerChild> | 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, loadImages and showWithDissolveTransition.
- * @example
- * ```typescript
- * let alien = new CanvasImage({
- *     anchor: { x: 0.5, y: 0.5 },
- *     x: 100,
- *     y: 100,
- * }, 'https://pixijs.com/assets/eggHead.png')
- * await alien.load()
- * GameWindowManager.addCanvasElement("alien", alien)
- * ```
- * @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> {
-    constructor(options?: SpriteOptions | Texture | undefined, imageLink?: string);
-    get memory(): ICanvasImageMemory;
-    set memory(memory: ICanvasImageMemory);
-    imageLink: string;
-    static from(source: Texture | TextureSourceLike, skipCache?: boolean): CanvasImage;
-    /**
-     * Load the image from the link and set the texture of the sprite.
-     * @param image The link of the image. If it is not set, it will use the imageLink property.
-     * @returns A promise that resolves when the image is loaded.
-     */
-    load(image?: string): 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'VN 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<ContainerChild> | keyof {
-        [K: symbol]: any;
-        [K: {} & string]: any;
-    }>(event: T, fn: (...args: EventEmitter.ArgumentMap<ContainerEvents<ContainerChild> & {
-        [K: symbol]: any;
-        [K: {} & string]: any;
-    }>[Extract<T, keyof ContainerEvents<ContainerChild> | 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;
-}
-
-type TickerArgsType = {
-    [id: 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> {
-    /**
-     * @param args The arguments that you want to pass to the ticker.
-     * @param duration The duration of the ticker. If is undefined, the ticker will be called every frame.
-     * @param priority The priority of the ticker. If is undefined, the priority will be UPDATE_PRIORITY.NORMAL.
-     */
-    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;
-}
-
-type TickerFadeAlphaProps = {
-    /**
-     * The speed of the fade
-     */
-    speed?: number;
-    /**
-     * The type of the fade
-     * @default "hide"
-     */
-    type?: "hide" | "show";
-    /**
-     * The limit of the fade
-     * @default type === "hide" ? 0 : 1
-     */
-    limit?: number;
-    /**
-     * The tag to remove after the fade is done
-     */
-    tagToRemoveAfter?: string[] | string;
-    /**
-     * If true, the fade only starts if the canvas element have a texture
-     */
-    startOnlyIfHaveTexture?: boolean;
-};
-
-/**
- * A ticker that fades the alpha of the canvas element of the canvas.
- * @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<TickerFadeAlphaProps> {
-    /**
-     * 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: TickerFadeAlphaProps, tags: string[]): void;
-}
-
-/**
- * is a string that represents a ticker id.
- * It is used to GameWindowManager.tickers to get the ticker class.
- */
-type TickerIdType = string;
-
-/**
- * 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: TickerIdType;
-    args: TArgs;
-    canvasElementTags: string[];
-    priority?: UPDATE_PRIORITY;
-    duration?: number;
-}
-interface IClassWithArgsHistoryForExport<TArgs extends TickerArgsType> {
-    className: TickerIdType;
-    args: TArgs;
-    canvasElementTags: string[];
-    priority?: UPDATE_PRIORITY;
-    duration?: number;
-}
-
-interface IDialogueHistory<T extends DialogueBaseModel = DialogueBaseModel> {
-    /**
-     * Dialogue to be shown in the game
-     */
-    dialoge?: T;
-    /**
-     * List of choices asked of the player
-     */
-    choices?: IStoratedChoiceMenuOptionLabel[];
-    /**
-     * Choice made by the player
-     */
-    choiceMade?: IStoratedChoiceMenuOptionLabel;
-    /**
-     * The index of the step in the history.
-     */
-    stepIndex: number;
-}
-
-/**
- * Interface exported canvas
- */
-interface ExportedCanvas {
-    currentTickers: IClassWithArgsHistoryForExport<any>[];
-    currentElements: {
-        [tag: string]: ICanvasBaseMemory;
-    };
-    childrenTagsOrder: string[];
-}
-
-/**
- * Interface exported storage data
- */
-interface ExportedStorage {
-    [key: string]: StorageElementType;
-}
-
-interface IOpenedLabel {
-    label: LabelIdType;
-    currentStepIndex: number;
-}
-
-/**
- * IHistoryStep is a interface that contains the information of a step in the history.
- */
-interface IHistoryStepData {
-    /**
-     * The browser path that occurred during the progression of the steps.
-     */
-    path: string;
-    /**
-     * The storage that occurred during the progression of the steps.
-     */
-    storage: ExportedStorage;
-    /**
-     * The index of the label that occurred during the progression of the steps.
-     */
-    labelIndex: number;
-    /**
-     * The canvas that occurred during the progression of the steps.
-     */
-    canvas: ExportedCanvas;
-    /**
-     * The opened labels that occurred during the progression of the steps.
-     */
-    openedLabels: IOpenedLabel[];
-}
-interface IHistoryStep<T extends DialogueBaseModel = DialogueBaseModel> {
-    /**
-     * The difference between the previous step and the current step.
-     */
-    diff: deepDiff.Diff<IHistoryStepData, IHistoryStepData>[];
-    /**
-     * The label id of the current step.
-     */
-    currentLabel?: LabelIdType;
-    /**
-     * The sha1 of the step function.
-     */
-    stepSha1: StepHistoryDataType;
-    /**
-     * The index of the step in the history.
-     */
-    index: number;
-    /**
-     * Dialogue to be shown in the game
-     */
-    dialoge?: T;
-    /**
-     * List of choices asked of the player
-     */
-    choices?: IStoratedChoiceMenuOptionLabel[];
-}
-
-/**
- * Interface exported step data
- */
-interface ExportedStep {
-    stepsHistory: IHistoryStep[];
-    openedLabels: IOpenedLabel[];
-    lastStepIndex: number;
-    originalStepData: IHistoryStepData | undefined;
-}
-
-interface ISaveData {
-    pixivn_version: string;
-    stepData: ExportedStep;
-    storageData: ExportedStorage;
-    canvasData: ExportedCanvas;
-    path: string;
-}
-
-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)[];
-}
-
-type TickerProgrationType = ITickerProgrationLinear | ITickerProgrationExponential;
-type ITickerProgrationLinear = {
-    amt: number;
-    limit?: number;
-    type: "linear";
-};
-type ITickerProgrationExponential = {
-    percentage: number;
-    limit?: number;
-    type: "exponential";
-};
-
-type TickerMoveProps = {
-    /**
-     * The speed of the movement
-     * @default 0.1
-     */
-    speed?: number;
-    /**
-     * The destination of the movement
-     */
-    destination: {
-        y: number;
-        x: number;
-    };
-    /**
-     * The progression of the speed
-     */
-    speedProgression?: TickerProgrationType;
-    /**
-     * If true, the rotation only starts if the canvas element have a texture
-     */
-    startOnlyIfHaveTexture?: boolean;
-};
-
-/**
- * A ticker that moves the canvas element of the canvas.
- * @example
- * ```typescript
- * let alien = addImage("alien", 'https://pixijs.com/assets/eggHead.png')
- * GameWindowManager.addCanvasElement("alien", alien);
- * const ticker = new TickerMove({
- *    speed: 0.1,
- *    destination: { x: 100, y: 100 },
- * }),
- * ```
- */
-declare class TickerMove extends TickerBase<TickerMoveProps> {
-    /**
-     * The method that will be called every frame to move the canvas element of the canvas.
-     * @param t The ticker that is calling this method
-     * @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: TickerMoveProps, tags: string[]): void;
-}
-
-type TickerRotateProps = {
-    /**
-     * The speed of the rotation
-     * @default 0.1
-     */
-    speed?: number;
-    /**
-     * The direction of the rotation
-     * @default true
-     */
-    clockwise?: boolean;
-    /**
-     * The progression of the speed
-     */
-    speedProgression?: TickerProgrationType;
-    /**
-     * If true, the rotation only starts if the canvas element have a texture
-     */
-    startOnlyIfHaveTexture?: boolean;
-};
-
-/**
- * A ticker that rotates the canvas element of the canvas.
- * @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<TickerRotateProps> {
-    /**
-     * 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: TickerRotateProps, 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 CharacterBaseModel('liam', { name: 'Liam'});
- * export const alice = new CharacterBaseModel('alice', { name: 'Alice'});
- * saveCharacter([liam, alice]);
- * ```
- */
-declare function saveCharacter<T extends CharacterBaseModel = CharacterBaseModel>(character: T | T[]): void;
-/**
- * is a function that returns the character by the id
- * @param id is the id of the character
- * @returns the character
- * @example
- * ```typescript
- * const liam = getCharacterById('liam');
- * ```
- */
-declare function getCharacterById<T extends CharacterBaseModel>(id: string): T | undefined;
-/**
- * is a function that returns all characters
- * @returns all characters
- * @example
- * ```typescript
- * const allCharacters = getAllCharacters();
- * ```
- */
-declare function getAllCharacters<T extends CharacterBaseModel>(): T[];
-
-/**
- * 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?: EventIdType): (target: typeof CanvasEvent<any>) => void;
-
-/**
- * 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?: LabelIdType): (target: typeof Label) => void;
-
-/**
- * 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?: TickerIdType): (target: typeof TickerBase<any>) => void;
-
-/**
- * Set the dialogue to be shown in the game
- * @param text Text of the dialogue
- * @example
- * ```typescript
- * setDialogue("Hello World")
- * setDialogue({
- *       character: "characterId",
- *       text: "Hello World"
- * })
- * setDialogue(new DialogueBaseModel("Hello World", character))
- * ```
- */
-declare function setDialogue<TCharacter extends CharacterBaseModel = CharacterBaseModel, TDialogue extends DialogueBaseModel = DialogueBaseModel>(props: {
-    character: string | TCharacter;
-    text: string;
-} | string | TDialogue): void;
-/**
- * Get the dialogue to be shown in the game
- * @returns Dialogue to be shown in the game
- */
-declare function getDialogue<T extends DialogueBaseModel = DialogueBaseModel>(): T | 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
- * setChoiceMenuOptions([
- *     new ChoiceMenuOptionLabel("Events Test", EventsTestLabel),
- *     new ChoiceMenuOptionLabel("Show Image Test", ShowImageTest),
- *     new ChoiceMenuOptionLabel("Ticker Test", TickerTestLabel),
- *     new ChoiceMenuOptionLabel("Tinting Test", TintingTestLabel),
- *     new ChoiceMenuOptionLabel("Base Canvas Element Test Label", BaseCanvasElementTestLabel)
- * ])
- * ```
- */
-declare function setChoiceMenuOptions(options: ChoiceMenuOptionsType): void;
-/**
- * Get the options to be shown in the game
- * @returns Options to be shown in the game
- */
-declare function getChoiceMenuOptions(): ChoiceMenuOptionsType | undefined;
-/**
- * Clear the options to be shown in the game
- */
-declare function clearChoiceMenuOptions(): void;
-/**
- * Get the history of the dialogues
- * @returns the history of the dialogues
- */
-declare function getDialogueHistory<T extends DialogueBaseModel = DialogueBaseModel>(): IDialogueHistory<T>[];
-
-/**
- * Set a flag to true or false.
- * @param name The name of the flag
- * @param value The value of the flag.
- */
-declare function setFlag(name: string, value: boolean): void;
-/**
- * Get the value of a flag
- * @param name The name of the flag
- * @returns The value of the flag
- */
-declare function getFlag(name: string): boolean;
-
-/**
- * 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 loadImages(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 image The imageUrl or the canvas element
- * @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 showWithDissolveTransition<T extends CanvasBase<any> | string = string>(tag: string, image: T, speed: number, priority?: UPDATE_PRIORITY): Promise<void>;
-
-/**
- * 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 loadSaveData(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
- *                 loadSaveJson(jsonString, navigate);
- *                 afterLoad && afterLoad();
- *             };
- *             reader.readAsText(file);
- *         }
- *     };
- *     input.click();
- * }
- * ```
- */
-declare function loadSaveJson(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>;
-
-/**
- * GameStepManager is a class that manages the steps and labels 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<DialogueBaseModel<CharacterBaseModel>>[];
-    private static _lastStepIndex;
-    /**
-     * lastStepIndex is the last step index that occurred during the progression of the steps. **Not is the length of the stepsHistory - 1.**
-     */
-    static get lastStepIndex(): number;
-    /**
-     * Increase the last step index that occurred during the progression of the steps.
-     */
-    private static increaseLastStepIndex;
-    private static _openedLabels;
-    static get openedLabels(): IOpenedLabel[];
-    /**
-     * currentLabelId is the current label id that occurred during the progression of the steps.
-     */
-    private static get currentLabelId();
-    /**
-     * currentLabel is the current label that occurred during the progression of the steps.
-     */
-    static get currentLabel(): Label | undefined;
-    private static get currentLabelStepIndex();
-    /**
-     * currentLabelStep is the current step that occurred during the progression of the steps. It can used to determine the game end.
-     */
-    static get isLastGameStep(): boolean;
-    /**
-     * lastHistoryStep is the last history step that occurred during the progression of the steps.
-     */
-    private static get lastHistoryStep();
-    private static _originalStepData;
-    private static get originalStepData();
-    private static set originalStepData(value);
-    /**
-     * 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
-     */
-    static closeCurrentLabel(): void;
-    /**
-     * Close all labels and add them to the history.
-     */
-    static closeAllLabels(): void;
-    /**
-     * Increase the current step index of the current label.
-     */
-    private static increaseCurrentStepIndex;
-    /**
-     * Execute the next step and add it to the history.
-     * @param props The props to pass to the step.
-     * @returns StepLabelResultType or undefined.
-     * @example
-     * ```typescript
-     *     function nextOnClick() {
-     *     setLoading(true)
-     *     GameStepManager.runNextStep(yourParams)
-     *         .then((result) => {
-     *             setUpdate((p) => p + 1)
-     *             setLoading(false)
-     *             if (result) {
-     *                 // your code
-     *             }
-     *         })
-     *         .catch((e) => {
-     *             setLoading(false)
-     *             console.error(e)
-     *         })
-     * }
-     * ```
-     */
-    static runNextStep(props: StepLabelPropsType): Promise<StepLabelResultType>;
-    /**
-     * Execute the current step and add it to the history.
-     * @param props The props to pass to the step.
-     * @returns StepLabelResultType or undefined.
-     */
-    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.
-     * @param props The props to pass to the label.
-     * @returns StepLabelResultType or undefined.
-     * @example
-     * ```typescript
-     * GameStepManager.callLabel(StartLabel, yourParams).then((result) => {
-     *     if (result) {
-     *         // your code
-     *     }
-     * })
-     * ```
-     * @example
-     * ```typescript
-     * // if you use it in a step label you should return the result.
-     * return GameStepManager.callLabel(StartLabel).then((result) => {
-     *     return result
-     * })
-     * ```
-     */
-    static callLabel(label: typeof Label | Label, props: StepLabelPropsType): Promise<StepLabelResultType>;
-    /**
-     * Execute the label, close all labels and add them to the history.
-     * Is a jump function in Ren'Py.
-     * @param label The label to execute.
-     * @param props The props to pass to the label.
-     * @returns StepLabelResultType or undefined.
-     * @example
-     * ```typescript
-     * GameStepManager.jumpLabel(StartLabel, yourParams).then((result) => {
-     *     if (result) {
-     *         // your code
-     *     }
-     * })
-     * ```
-     * @example
-     * ```typescript
-     * // if you use it in a step label you should return the result.
-     * return GameStepManager.jumpLabel(StartLabel).then((result) => {
-     *     return result
-     * })
-     * ```
-     */
-    static jumpLabel(label: typeof Label | Label, props: StepLabelPropsType): Promise<StepLabelResultType>;
-    /**
-     * 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 goBackInternal;
-    /**
-     * Return true if it is possible to go back.
-     */
-    static get canGoBack(): boolean;
-    /**
-     * 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 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;
-        LAST_MENU_OPTIONS_ADDED_IN_STEP_MEMORY_KEY: string;
-        CHARACTER_CATEGORY_KEY: string;
-        FLAGS_CATEGORY_KEY: 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
-     */
-    private static addCanvasIntoElement;
-    /**
-     * 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, CharacterBaseModel, type CharacterBaseModelProps, ChoiceMenuOptionLabel, type ChoiceMenuOptionsType, DialogueBaseModel, 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 IDialogueHistory, type IHistoryStep, type IHistoryStepData, type IOpenedLabel, type ISaveData, type ITextureMemory, type ITicker, type ITickersSteps, Label, LabelRunModeEnum, Pause, type PauseType, PauseValueType, Repeat, type RepeatType, type StepLabelProps, type StepLabelResult, type StepLabelType, type StorageElementType, StoredClassModel, TickerBase, TickerFadeAlpha, type TickerFadeAlphaProps, TickerMove, type TickerProgrationType, TickerRotate, type TickerRotateProps, addImage, canvasElementDecorator, clearAllGameDatas, clearChoiceMenuOptions, clearDialogue, eventDecorator, getAllCharacters, getCharacterById, getChoiceMenuOptions, getDialogue, getDialogueHistory, getFlag, getSaveData, getSaveJson, getTexture, labelDecorator, loadImages, loadSaveData, loadSaveJson, removeCanvasElement, saveCharacter, setChoiceMenuOptions, setDialogue, setFlag, showWithDissolveTransition, tickerDecorator };
+export { default as CanvasEvent } from './classes/CanvasEvent.mjs';
+export { default as CharacterBaseModel, CharacterBaseModelProps } from './classes/CharacterBaseModel.mjs';
+export { default as ChoiceMenuOptionLabel } from './classes/ChoiceMenuOptionLabel.mjs';
+export { default as DialogueBaseModel } from './classes/DialogueBaseModel.mjs';
+export { default as Label } from './classes/Label.mjs';
+export { default as StoredClassModel } from './classes/StoredClassModel.mjs';
+export { default as CanvasBase } from './classes/canvas/CanvasBase.mjs';
+export { default as CanvasContainer } from './classes/canvas/CanvasContainer.mjs';
+export { default as CanvasImage } from './classes/canvas/CanvasImage.mjs';
+export { default as CanvasSprite } from './classes/canvas/CanvasSprite.mjs';
+export { default as CanvasText } from './classes/canvas/CanvasText.mjs';
+export { I as ITicker, T as TickerBase } from './TickerBase-CFEJHstJ.mjs';
+export { default as TickerFadeAlpha } from './classes/ticker/TickerFadeAlpha.mjs';
+export { default as TickerMove } from './classes/ticker/TickerMove.mjs';
+export { default as TickerRotate } from './classes/ticker/TickerRotate.mjs';
+export { default as canvasElementDecorator } from './decorators/CanvasElementDecorator.mjs';
+export { getAllCharacters, getCharacterById, saveCharacter } from './decorators/CharacterDecorator.mjs';
+export { default as eventDecorator } from './decorators/EventDecorator.mjs';
+export { default as labelDecorator } from './decorators/LabelDecorator.mjs';
+export { default as tickerDecorator } from './decorators/TickerDecorator.mjs';
+export { LabelRunModeEnum } from './enums/LabelRunModeEnum.mjs';
+export { clearChoiceMenuOptions, clearDialogue, getChoiceMenuOptions, getDialogue, getDialogueHistory, setChoiceMenuOptions, setDialogue } from './functions/DialogueUtility.mjs';
+export { getFlag, setFlag } from './functions/FlagsUtility.mjs';
+export { clearAllGameDatas } from './functions/GameUtility.mjs';
+export { addImage, loadImages, removeCanvasElement, showWithDissolveTransition } from './functions/ImageUtility.mjs';
+export { getSaveData, getSaveJson, loadSaveData, loadSaveJson } from './functions/SavesUtility.mjs';
+export { getTexture } from './functions/TextureUtility.mjs';
+export { IClassWithArgsHistory, IClassWithArgsHistoryForExport } from './interface/IClassWithArgsHistory.mjs';
+export { IDialogueHistory } from './interface/IDialogueHistory.mjs';
+export { default as IHistoryStep, IHistoryStepData } from './interface/IHistoryStep.mjs';
+export { default as IOpenedLabel } from './interface/IOpenedLabel.mjs';
+export { default as ISaveData } from './interface/ISaveData.mjs';
+export { default as ITickersSteps } from './interface/ITickersSteps.mjs';
+export { TickerProgrationType } from './interface/TickerProgrationType.mjs';
+export { default as ICanvasBaseMemory } from './interface/canvas/ICanvasBaseMemory.mjs';
+export { default as ICanvasContainerMemory } from './interface/canvas/ICanvasContainerMemory.mjs';
+export { default as ICanvasImageMemory } from './interface/canvas/ICanvasImageMemory.mjs';
+export { ICanvasSpriteBaseMemory, default as ICanvasSpriteMemory } from './interface/canvas/ICanvasSpriteMemory.mjs';
+export { default as ICanvasTextTextMemory } from './interface/canvas/ICanvasTextTextMemory.mjs';
+export { default as ITextureMemory } from './interface/canvas/ITextureMemory.mjs';
+export { default as ExportedCanvas } from './interface/export/ExportedCanvas.mjs';
+export { default as ExportedStep } from './interface/export/ExportedStep.mjs';
+export { default as ExportedStorage } from './interface/export/ExportedStorage.mjs';
+export { default as GameStepManager } from './managers/StepManager.mjs';
+export { default as GameStorageManager } from './managers/StorageManager.mjs';
+export { default as GameWindowManager } from './managers/WindowManager.mjs';
+export { CanvasEventNamesType } from './types/CanvasEventNamesType.mjs';
+export { ChoiceMenuOptionsType } from './types/ChoiceMenuOptionsType.mjs';
+export { Pause, PauseType, PauseValueType } from './types/PauseType.mjs';
+export { Repeat, RepeatType } from './types/RepeatType.mjs';
+export { StepLabelType } from './types/StepLabelType.mjs';
+export { StorageElementType } from './types/StorageElementType.mjs';
+export { TickerFadeAlphaProps } from './types/ticker/TickerFadeAlphaProps.mjs';
+export { TickerRotateProps } from './types/ticker/TickerRotateProps.mjs';
+import './types/LabelIdType.mjs';
+import './types/StepHistoryDataType.mjs';
+import './types/ticker/TickerMoveProps.mjs';
+import './types/CanvasElementTagType.mjs';
+import './types/EventIdType.mjs';
+import './types/TickerIdType.mjs';
+import 'deep-diff';
+import './override/StepLabelProps.mjs';
+import './override/StepLabelResult.mjs';