@drincs/pixi-vn 0.1.2 → 0.1.4

package/dist/index.d.mts

@@ -0,0 +1,1510 @@
+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';
+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 CharacterModelBase extends StoredClassModel implements ICharacterModelBase {
+ *     constructor(id: string, props: ICharacterModelBase) {
+ *         super(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.updateStorageProperty<string>("name", value)
+ *     }
+ *     private defaultSurname?: string
+ *     get surname(): string | undefined {
+ *         return this.getStorageProperty<string>("surname") || this.defaultSurname
+ *     }
+ *     set surname(value: string | undefined) {
+ *         this.updateStorageProperty<string>("surname", value)
+ *     }
+ * }
+ * ```
+ */
+declare abstract class StoredClassModel {
+    id: string;
+    constructor(id: string);
+    private get nameClass();
+    updateStorageProperty<T>(key: string, value: T | undefined): 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(id: 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);
+    private _icon?;
+    get icon(): string | undefined;
+    private _color?;
+    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;
+
+/**
+ * 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?" })
+ *                 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);
+}
+interface IStoratedChoiceMenuOptionLabel {
+    text: string;
+    label: LabelIdType;
+    type: LabelRunModeEnum;
+}
+
+/**
+ * Base class for all dialogue models. I suggest you extend this class to create your own dialogue models.
+ */
+declare class DialogueModelBase {
+    constructor(text: string, characterId: string | undefined);
+    /**
+     * The text of the dialogue.
+     */
+    text: string;
+    /**
+     * The id of the character that is speaking.
+     */
+    characterId?: string;
+}
+
+/**
+ * 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 | 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 showImageWithDissolveTransition.
+ * @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'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 | 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 = {
+    [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> {
+    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 id
+ * @param id is the id of the character
+ * @returns the character
+ * @example
+ * ```typescript
+ * const liam = getCharacterById('liam');
+ * ```
+ */
+declare function getCharacterById<T extends CharacterModelBase>(id: 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?: 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 string that represents a ticker id.
+ * It is used to GameWindowManager.tickers to get the ticker class.
+ */
+type TickerIdType = 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?: TickerIdType): (target: typeof TickerBase<any>) => 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: 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 DialogueModelBase = DialogueModelBase> {
+    /**
+     * 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 DialogueModelBase = DialogueModelBase> {
+    /**
+     * 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 {
+    version: string;
+    stepData: ExportedStep;
+    storageData: ExportedStorage;
+    canvasData: ExportedCanvas;
+    path: string;
+}
+
+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)[];
+}
+
+/**
+ * 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[];
+
+/**
+ * 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"
+ * })
+ * ```
+ */
+declare function setDialogue<T extends CharacterModelBase = CharacterModelBase>(props: {
+    character: string | T;
+    text: string;
+} | string): void;
+/**
+ * Get the dialogue to be shown in the game
+ * @returns Dialogue to be shown in the game
+ */
+declare function getDialogue<T extends DialogueModelBase = DialogueModelBase>(): 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 DialogueModelBase = DialogueModelBase>(): IDialogueHistory<T>[];
+
+/**
+ * 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 showImageWithDissolveTransition(tag: string, imageUrl: string, 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<DialogueModelBase>[];
+    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[];
+    /**
+     * currentLabel is the current label that occurred during the progression of the steps.
+     */
+    private static get currentLabel();
+    /**
+     * 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();
+    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.
+     * @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 goBackInternal;
+    /**
+     * 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_PREKEY: 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, CharacterModelBase, ChoiceMenuOptionLabel, type ChoiceMenuOptionsType, 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 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 StepLabelType, type StorageElementType, StoredClassModel, TickerBase, TickerFadeAlpha, type TickerProgrationType, TickerRotate, addImage, canvasElementDecorator, clearAllGameDatas, clearChoiceMenuOptions, clearDialogue, eventDecorator, getCharacterById, getChoiceMenuOptions, getDialogue, getDialogueHistory, getSaveData, getSaveJson, getTexture, labelDecorator, loadSaveData, loadSaveJson, removeCanvasElement, saveCharacter, setChoiceMenuOptions, setDialogue, showCanvasImages, showImageWithDissolveTransition, tickerDecorator };