narrat 2.2.14 → 2.2.17

package/dist/stores/main-store.d.ts

@@ -1,391 +1,813 @@
-import { GameSave } from '../types/game-save';
-import { AppOptions, Config } from '../config';
-export interface ErrorState {
-    text: string;
-}
-interface MainState {
-    ready: boolean;
-    playing: boolean;
-    errors: ErrorState[];
-    playTime: {
-        start: number;
-        previousPlaytime: number;
-    };
-    saveSlot: number;
-    options: AppOptions;
-    flowState: 'menu' | 'playing';
-    modal: string | false;
-    paused: boolean;
-}
-export interface MainSaveData {
-    playTime: number;
-}
-export declare const useMain: import("pinia").StoreDefinition<"main", MainState, {
-    isInGame(state: {
-        ready: boolean;
-        playing: boolean;
-        errors: {
-            text: string;
-        }[];
-        playTime: {
-            start: number;
-            previousPlaytime: number;
-        };
-        saveSlot: number;
-        options: {
-            baseAssetsPath?: string | undefined;
-            logging: boolean;
-            debug: boolean;
-        };
-        flowState: 'menu' | 'playing';
-        modal: string | false;
-        paused: boolean;
-    } & import("pinia").PiniaCustomStateProperties<MainState>): boolean;
-}, {
-    setup(scriptPaths: string[], config: Config): Promise<void>;
-    startMachine(): void;
-    setSaveSlot(slot: number): void;
-    startGame(saveSlot: number): Promise<void>;
-    loadGame(save: GameSave, saveSlot: number): Promise<void>;
-    playerAnswered(choice: number | string): void;
-    menuReturn(): void;
-    createError(text: string): void;
-    clearErrors(): void;
-    setFlowState(flowState: 'menu' | 'playing'): void;
-    openModal(modal: string): void;
-    closeModal(): void;
-    toggleMenu(): void;
-    pause(): void;
-    unpause(): void;
-    setOptions(options: AppOptions): void;
-    startPlaying(): void;
-    reset(): void;
-    resetAllStores(): void;
-    generateSaveData(): MainSaveData;
-    loadSaveData(data: MainSaveData): void;
-    saveGame(): void;
-    setLoadedData(save: GameSave): void;
-    getAllStates(): {
-        main: any & {
-            ready: boolean;
-            playing: boolean;
-            errors: {
-                text: string;
-            }[];
-            playTime: {
-                start: number;
-                previousPlaytime: number;
-            };
-            saveSlot: number;
-            options: {
-                baseAssetsPath?: string | undefined;
-                logging: boolean;
-                debug: boolean;
-            };
-            flowState: 'menu' | 'playing';
-            modal: string | false;
-            paused: boolean;
-        } & import("pinia")._StoreWithState<"main", MainState, {
-            isInGame(state: {
-                ready: boolean;
-                playing: boolean;
-                errors: {
-                    text: string;
-                }[];
-                playTime: {
-                    start: number;
-                    previousPlaytime: number;
-                };
-                saveSlot: number;
-                options: {
-                    baseAssetsPath?: string | undefined;
-                    logging: boolean;
-                    debug: boolean;
-                };
-                flowState: 'menu' | 'playing';
-                modal: string | false;
-                paused: boolean;
-            } & import("pinia").PiniaCustomStateProperties<MainState>): boolean;
-        }, any> & import("pinia")._StoreWithGetters<{
-            isInGame(state: {
-                ready: boolean;
-                playing: boolean;
-                errors: {
-                    text: string;
-                }[];
-                playTime: {
-                    start: number;
-                    previousPlaytime: number;
-                };
-                saveSlot: number;
-                options: {
-                    baseAssetsPath?: string | undefined;
-                    logging: boolean;
-                    debug: boolean;
-                };
-                flowState: 'menu' | 'playing';
-                modal: string | false;
-                paused: boolean;
-            } & import("pinia").PiniaCustomStateProperties<MainState>): boolean;
-        }> & import("pinia").PiniaCustomProperties<string, import("pinia").StateTree, import("pinia")._GettersTree<import("pinia").StateTree>, import("pinia")._ActionsTree>;
-        screens: import("pinia").Store<"screens", import("./screens-store").ScreenState, {}, {
-            setScreen(screen: string, layer: number, transition?: import("../utils/transition").AddTransition | undefined): Promise<void>;
-            finishTransition(layer: number): void;
-            transitionScreen(screen: string, transition: import("../utils/transition").AddTransition, layer?: number | undefined): Promise<void>;
-            emptyLayer(layer: number): void;
-            setButtons(config: Config): void;
-            changeButton(button: string, newValue: import("./screens-store").ButtonStateValue): void;
-            generateSaveData(): import("./screens-store").ScreenSave;
-            loadSaveData(data: import("./screens-store").ScreenSave): void;
-        }>;
-        skills: import("pinia").Store<"skills", import("./skills").Skills, {}, {
-            setupSkillCheck(skillCheck: import("./skills").SkillCheckState, id: string): void;
-            passSkillCheck(skillCheckId: string, hide?: boolean | undefined): void;
-            failSkillCheck(skillCheckId: string, hide?: boolean | undefined): void;
-            generateSaveData(): import("./skills").Skills;
-            getSkillCheck(id: string): import("./skills").SkillCheckState;
-            createSkillCheckState(): import("./skills").SkillCheckState;
-            loadSaveData(data: import("./skills").Skills): void;
-            setupSkills(skills: {
-                [key: string]: import("../config").SkillData;
-            }): void;
-            getSkill(skill: string): import("./skills").SkillState;
-            getSkillLevel(skill: string): number;
-            getSkillXp(skill: string): number;
-            addXp(skill: string, xp: number): void;
-            setSkillLevel(skill: string, level: number): void;
-            incrementSkill(skill: string, amount: number): void;
-            levelledUp(skill: string): void;
-        }>;
-        dialog: import("pinia").Store<"dialog", {
-            dialog: import("./dialog-store").DialogKey[];
-        }, {
-            currentDialog(): import("./dialog-store").DialogKey;
-        }, {
-            generateSaveData(): {
-                dialog: import("./dialog-store").DialogKey[];
-            };
-            loadSaveData(data: {
-                dialog: import("./dialog-store").DialogKey[];
-            }): void;
-            addDialog(dialog: import("./dialog-store").AddDialogParams): void;
-            clearDialog(): void;
-            reset(): void;
-        }>;
-        vm: import("pinia").Store<"vm", import("./vm-store").VMState, {
-            currentFrame(state: {
-                commandsWaitingForPlayerAnswer: {
-                    args: (import("../types/parser").Parser.Primitive | {
-                        code: string;
-                        command: {
-                            commandType: string;
-                            operator: string;
-                            args: (import("../types/parser").Parser.Primitive | any)[];
-                            options: import("../types/parser").Parser.DefaultArg;
-                            staticOptions: {};
-                        };
-                        fileName: string;
-                        line: number;
-                    })[];
-                    commandType: string;
-                    options: any;
-                    code: string;
-                    staticOptions: any;
-                    operator: string;
-                    line: number;
-                    fileName: string;
-                    finishCommand?: ((res: any) => void) | undefined;
-                }[];
-                stack: {
-                    blocks: {
-                        currentIndex: number;
-                        branchData: {
-                            branch: {
-                                code: string;
-                                command: {
-                                    commandType: string;
-                                    operator: string;
-                                    args: (import("../types/parser").Parser.Primitive | any)[];
-                                    options: import("../types/parser").Parser.DefaultArg;
-                                    staticOptions: {};
-                                };
-                                fileName: string;
-                                line: number;
-                            }[];
-                            args?: string[] | undefined;
-                        };
-                    }[];
-                    label: string;
-                    scope: {
-                        [key: string]: any;
-                    };
-                    returnValue: any;
-                }[];
-                script: import("../types/parser").Parser.ParsedScript;
-                data: import("./vm-store").DataState;
-                lastLabel: string;
-                jumpTarget?: {
-                    currentIndex: number;
-                    branchData: {
-                        branch: {
-                            code: string;
-                            command: {
-                                commandType: string;
-                                operator: string;
-                                args: (import("../types/parser").Parser.Primitive | any)[];
-                                options: import("../types/parser").Parser.DefaultArg;
-                                staticOptions: {};
-                            };
-                            fileName: string;
-                            line: number;
-                        }[];
-                        args?: string[] | undefined;
-                    };
-                    label: string;
-                    scope?: {
-                        [key: string]: any;
-                    } | undefined;
-                    args?: any[] | undefined;
-                } | undefined;
-            } & import("pinia").PiniaCustomStateProperties<import("./vm-store").VMState>): import("./vm-store").MachineFrame | undefined;
-            scope(): {
-                [key: string]: any;
-            };
-            currentBlock(): import("./vm-store").MachineBlock | undefined;
-            currentLine(): import("../types/parser").Parser.ParsedExpression<import("../types/parser").Parser.DefaultArg, {}> | undefined;
-            commandWaitingForAnswer(): import("../types/parser").Parser.Command<any, any> | undefined;
-        }, {
-            generateSaveData(): import("./vm-store").VMSave;
-            loadSaveData(data: import("./vm-store").VMSave): void;
-            setReturnValue(value: any): void;
-            waitForPlayerAnswer(cmd: import("../types/parser").Parser.Command<any, any>): void;
-            popAnswerQueue(): {
-                args: (import("../types/parser").Parser.Primitive | {
-                    code: string;
-                    command: {
-                        commandType: string;
-                        operator: string;
-                        args: (import("../types/parser").Parser.Primitive | any)[];
-                        options: import("../types/parser").Parser.DefaultArg;
-                        staticOptions: {};
-                    };
-                    fileName: string;
-                    line: number;
-                })[];
-                commandType: string;
-                options: any;
-                code: string;
-                staticOptions: any;
-                operator: string;
-                line: number;
-                fileName: string;
-                finishCommand?: ((res: any) => void) | undefined;
-            } | undefined;
-            addScopedVariable(key: string, value: any): void;
-            loadScripts(scriptPaths: string[]): Promise<void>;
-            start(): void;
-            setLastLabel(label: string): void;
-            reset(): void;
-            setScript(script: import("../types/parser").Parser.ParsedScript): void;
-            overrideData(data: import("./vm-store").DataState): void;
-            setStack(stack: import("./vm-store").SetFrameOptions): void;
-            frameOptionsToFrame(frame: import("./vm-store").SetFrameOptions): import("./vm-store").MachineFrame;
-            addBlock(frame: import("./vm-store").MachineFrame, block: import("./vm-store").MachineBlock): void;
-            addAndRunBlock(block: import("./vm-store").MachineBlock): Promise<any>;
-            setData(path: string, value: any): void;
-            addInstruction(path: string, value: any): void;
-            addFrame(newStackOptions: import("./vm-store").AddFrameOptions): void;
-            addAndRunFrame(newStackOptions: import("./vm-store").AddFrameOptions): Promise<any>;
-            runFrame(): Promise<any>;
-            cleanFrame(): any;
-            runBlock(): Promise<any>;
-            cleanBlock(): void;
-            runGame(): Promise<void>;
-            nextLineOnly(): Promise<boolean>;
-            isBlockFinished(): boolean;
-            reachedEndOfScript(): void;
-            runLineOnly(): Promise<any>;
-            runLabelFunction(label: string, ...args: any[]): Promise<any>;
-            runCustomFrame(stack: import("./vm-store").AddFrameOptions): void;
-            jumpToLabel(label: string, ...args: any[]): void;
-            runThenGoBackToPreviousDialog(label: string, ...args: any[]): Promise<any>;
-        }>;
-        hud: import("pinia").Store<"hud", import("./hud-stats-store").HudState, {}, {
-            setupHudStats(stats: {
-                [key: string]: import("../config").HudStatConfig;
-            }): void;
-            setStat(stat: string, value: number): void;
-            addStat(stat: string, value: number): void;
-            getStat(stat: string): import("./hud-stats-store").HudStat;
-            getStatValue(stat: string): number;
-            generateSaveData(): import("./hud-stats-store").HudState;
-            loadSaveData(data: import("./hud-stats-store").HudState): void;
-        }>;
-        audio: import("pinia").Store<"audio", import("./audio-store").AudioState, {}, {
-            stopAll(): void;
-            stopChannel(mode: "sound" | "music" | "ambiant", channelIndex: number): Promise<void>;
-            pauseChannel(mode: "sound" | "music" | "ambiant", channelIndex: number): Promise<void>;
-            playChannel(mode: "sound" | "music" | "ambiant", audio: string, channelIndex: number): Promise<void>;
-            changeChannel(mode: "sound" | "music" | "ambiant", audio: string, channelIndex: number): Promise<void>;
-            actuallyStopChannel(channel: import("./audio-store").AudioChannel): void;
-            getAudioChannel(mode: "sound" | "music" | "ambiant", channelIndex: number): import("./audio-store").AudioChannel | null;
-            setAudioChannel(mode: "sound" | "music" | "ambiant", channelIndex: number, value: import("./audio-store").AudioChannel | null): void;
-            actuallyPlayChannel(mode: "sound" | "music" | "ambiant", channelIndex: number, audio: string): Promise<void>;
-            reloadAudio(save: import("./audio-store").AudioSave): void;
-            stopSound(key: string): void;
-            generateSaveData(): import("./audio-store").AudioSave;
-            loadSaveData(data: import("./audio-store").AudioSave): void;
-            reset(): void;
-            setModeVolume(mode: "sound" | "music" | "ambiant", volume: number): void;
-            setMasterVolume(volume: number): void;
-            modeVolume(mode: "sound" | "music" | "ambiant"): number;
-        }>;
-        rendering: import("pinia").Store<"rendering", import("./rendering-store").RenderingState, {}, {
-            updateScreenSize(width: number, height: number, textWidth: number): void;
-        }>;
-        notifications: import("pinia").Store<"notifications", import("./notification-store").NotificationsState, {}, {
-            addNotification(text: string): Promise<void>;
-            deleteNotification(id: string): void;
-            disableNotifications(): void;
-            enableNotifications(): void;
-        }>;
-        inventory: import("pinia").Store<"inventory", import("./inventory-store").InventoryState, {}, {
-            generateSaveData(): import("./inventory-store").InventoryState;
-            loadSaveData(save: import("./inventory-store").InventoryState): void;
-            setupItems(items: {
-                [key: string]: import("../config").ItemData;
-            }): void;
-            hasItem(itemId: string, amount?: number | undefined): boolean;
-            getExistingItem(id: string): import("./inventory-store").ItemState | undefined;
-            getItemAmount(id: string): number;
-            add(item: import("./inventory-store").ItemState): void;
-            enableInteraction(tag?: string | undefined): void;
-            disableInteraction(tag?: string | undefined): void;
-            onScriptStart(): void;
-            onScriptEnd(): void;
-            isInteractionTagBlocked(tag?: string | undefined): boolean;
-            remove(item: import("./inventory-store").ItemState): void;
-            deleteItem(id: string): void;
-        }>;
-        quests: import("pinia").Store<"quests", import("./quest-log").QuestLogState, {}, {
-            getQuest(questId: string): import("./quest-log").QuestState;
-            getObjective(questId: string, objectiveId: string): import("./quest-log").ObjectiveState;
-            setupQuests(quests: {
-                [key: string]: import("../config").QuestData;
-            }): void;
-            startQuest(questId: string): void;
-            startObjective(questId: string, objectiveId: string): void;
-            completeObjective(questId: string, objectiveId: string): void;
-            completeQuest(questId: string, ending?: string | undefined): void;
-            isQuestCompleted(questId: string): boolean;
-            isObjectiveCompleted(questId: string, objectiveId: string): boolean;
-            isQuestStarted(questId: string): boolean;
-            isObjectiveStarted(questId: string, objectiveId: string): boolean;
-            removeQuest(id: string): void;
-            generateSaveData(): import("./quest-log").QuestLogState;
-            loadSaveData(data: import("./quest-log").QuestLogState): void;
-        }>;
-    };
-    overrideStates(override: any): void;
-}>;
-export {};
+import { AppOptions } from '../types/app-types';
+import { GameSave } from '../types/game-save';
+import { ChosenSlot } from '../utils/save-helpers';
+import { TypedEmitter } from '../utils/typed-emitter';
+export declare function defaultAppOptions(): AppOptions;
+export interface MainEvents {
+    gameLoaded: () => void;
+}
+export declare class MainStoreListener extends TypedEmitter<MainEvents> {
+}
+export interface ErrorState {
+    text: string;
+}
+interface MainState {
+    ready: boolean;
+    playing: boolean;
+    errors: ErrorState[];
+    playTime: {
+        start: number;
+        previousPlaytime: number;
+    };
+    saveSlot: string;
+    options: AppOptions;
+    flowState: 'engine-splash' | 'game-splash' | 'menu' | 'playing';
+    modal: string | false;
+    paused: boolean;
+    loading: {
+        step: string;
+        percentage: number;
+        loaded: boolean;
+    };
+    alerts: {
+        title: string;
+        text: string;
+        resolver: () => void;
+        id: string;
+    }[];
+    saving: {
+        withPrompt?: boolean;
+        name?: string;
+        resolver: () => void;
+    } | null;
+    saveData?: GameSave;
+    listener: MainStoreListener;
+}
+export interface MainSaveData {
+    playTime: number;
+}
+export declare const useMain: import("pinia").StoreDefinition<"main", MainState, {
+    isInGame(state: {
+        ready: boolean;
+        playing: boolean;
+        errors: {
+            text: string;
+        }[];
+        playTime: {
+            start: number;
+            previousPlaytime: number;
+        };
+        saveSlot: string;
+        options: {
+            baseAssetsPath: string;
+            baseDataPath: string;
+            charactersPath: string;
+            configPath: string;
+            logging: boolean;
+            debug: boolean;
+        };
+        flowState: 'engine-splash' | 'game-splash' | 'menu' | 'playing';
+        modal: string | false;
+        paused: boolean;
+        loading: {
+            step: string;
+            percentage: number;
+            loaded: boolean;
+        };
+        alerts: {
+            title: string;
+            text: string;
+            resolver: () => void;
+            id: string;
+        }[];
+        saving: {
+            withPrompt?: boolean | undefined;
+            name?: string | undefined;
+            resolver: () => void;
+        } | null;
+        saveData?: {
+            version: string;
+            skills: {
+                skillChecks: {
+                    [key: string]: import("./skills").SkillCheckState;
+                };
+                skills: import("./skills").SkillsState;
+            };
+            screen: {
+                layers: string[];
+                buttons: import("./screens-store").ButtonsState;
+            };
+            main: {
+                playTime: number;
+            };
+            dialog: {
+                dialog: {
+                    speaker: string;
+                    text: string;
+                    pose?: string | undefined;
+                    cssClass?: string | undefined;
+                    choices?: {
+                        choice: string;
+                        originalIndex: number;
+                        allowed: boolean;
+                    }[] | undefined;
+                    textField?: boolean | undefined;
+                    interactive: boolean;
+                    id: string;
+                }[];
+            };
+            vm: {
+                lastLabel: string;
+                data: import("./vm-store").DataState;
+            };
+            audio: {
+                modes: {
+                    [key: string]: import("./audio-store").AudioModeState;
+                };
+                masterVolume: number;
+            };
+            hud: {
+                hudStats: import("./hud-stats-store").HudStatsState;
+            };
+            inventory: {
+                items: {
+                    [key: string]: import("./inventory-store").ItemState;
+                };
+                interactionTags: {
+                    [key: string]: {
+                        blockedInteraction: boolean;
+                    };
+                };
+            };
+            quests: {
+                quests: {
+                    [key: string]: import("./quest-log").QuestState;
+                };
+            };
+            metadata: {
+                saveDate: string;
+                name: string;
+                slotType: "manual" | "auto";
+                id: string;
+                createdCounter: number;
+            };
+        } | undefined;
+        listener: {
+            listeners: {
+                gameLoaded: Set<() => void>;
+            };
+            on: <Event_1 extends "gameLoaded">(event: Event_1, listener: MainEvents[Event_1]) => MainEvents[Event_1];
+            off: <Event_2 extends "gameLoaded">(event: Event_2, listener: MainEvents[Event_2]) => MainEvents[Event_2];
+            once: <Event_3 extends "gameLoaded">(event: Event_3, listener: MainEvents[Event_3]) => MainEvents[Event_3];
+            emit: <Event_4 extends "gameLoaded">(event: Event_4, ...args: any[]) => void;
+            clear: () => void;
+        };
+    } & import("pinia").PiniaCustomStateProperties<MainState>): boolean;
+}, {
+    setup(): Promise<void>;
+    engineLoading(): Promise<void>;
+    alert(title: string, text: string): Promise<void>;
+    closeAlert(id: string): void;
+    startMachine(): void;
+    setSaveSlot(slot: string): void;
+    startGame(saveSlot: string): Promise<void>;
+    loadGame(save: GameSave, saveSlot: string): Promise<void>;
+    manualSave({ saveName, withPrompt, }: {
+        saveName?: string | undefined;
+        withPrompt?: boolean | undefined;
+    }): Promise<void>;
+    finishManualSave(slotData: ChosenSlot | null, yes: boolean): void;
+    playerAnswered(choice: number | string): void;
+    menuReturn(): void;
+    createError(text: string): void;
+    clearErrors(): void;
+    setFlowState(flowState: 'menu' | 'playing'): void;
+    openModal(modal: string): void;
+    closeModal(): void;
+    toggleMenu(): void;
+    pause(): void;
+    unpause(): void;
+    setOptions(options: AppOptions): void;
+    startPlaying(): void;
+    reset(): void;
+    resetAllStores(): void;
+    generateSaveData(): MainSaveData;
+    loadSaveData(data: MainSaveData): void;
+    autoSaveGame({ slotId, name }: {
+        slotId?: string | undefined;
+        name?: string | undefined;
+    }): void;
+    setLoadedData(save: GameSave): void;
+    getAllStates(): {
+        main: any & {
+            ready: boolean;
+            playing: boolean;
+            errors: {
+                text: string;
+            }[];
+            playTime: {
+                start: number;
+                previousPlaytime: number;
+            };
+            saveSlot: string;
+            options: {
+                baseAssetsPath: string;
+                baseDataPath: string;
+                charactersPath: string;
+                configPath: string;
+                logging: boolean;
+                debug: boolean;
+            };
+            flowState: 'engine-splash' | 'game-splash' | 'menu' | 'playing';
+            modal: string | false;
+            paused: boolean;
+            loading: {
+                step: string;
+                percentage: number;
+                loaded: boolean;
+            };
+            alerts: {
+                title: string;
+                text: string;
+                resolver: () => void;
+                id: string;
+            }[];
+            saving: {
+                withPrompt?: boolean | undefined;
+                name?: string | undefined;
+                resolver: () => void;
+            } | null;
+            saveData?: {
+                version: string;
+                skills: {
+                    skillChecks: {
+                        [key: string]: import("./skills").SkillCheckState;
+                    };
+                    skills: import("./skills").SkillsState;
+                };
+                screen: {
+                    layers: string[];
+                    buttons: import("./screens-store").ButtonsState;
+                };
+                main: {
+                    playTime: number;
+                };
+                dialog: {
+                    dialog: {
+                        speaker: string;
+                        text: string;
+                        pose?: string | undefined;
+                        cssClass?: string | undefined;
+                        choices?: {
+                            choice: string;
+                            originalIndex: number;
+                            allowed: boolean;
+                        }[] | undefined;
+                        textField?: boolean | undefined;
+                        interactive: boolean;
+                        id: string;
+                    }[];
+                };
+                vm: {
+                    lastLabel: string;
+                    data: import("./vm-store").DataState;
+                };
+                audio: {
+                    modes: {
+                        [key: string]: import("./audio-store").AudioModeState;
+                    };
+                    masterVolume: number;
+                };
+                hud: {
+                    hudStats: import("./hud-stats-store").HudStatsState;
+                };
+                inventory: {
+                    items: {
+                        [key: string]: import("./inventory-store").ItemState;
+                    };
+                    interactionTags: {
+                        [key: string]: {
+                            blockedInteraction: boolean;
+                        };
+                    };
+                };
+                quests: {
+                    quests: {
+                        [key: string]: import("./quest-log").QuestState;
+                    };
+                };
+                metadata: {
+                    saveDate: string;
+                    name: string;
+                    slotType: "manual" | "auto";
+                    id: string;
+                    createdCounter: number;
+                };
+            } | undefined;
+            listener: {
+                listeners: {
+                    gameLoaded: Set<() => void>;
+                };
+                on: <Event_1 extends "gameLoaded">(event: Event_1, listener: MainEvents[Event_1]) => MainEvents[Event_1];
+                off: <Event_2 extends "gameLoaded">(event: Event_2, listener: MainEvents[Event_2]) => MainEvents[Event_2];
+                once: <Event_3 extends "gameLoaded">(event: Event_3, listener: MainEvents[Event_3]) => MainEvents[Event_3];
+                emit: <Event_4 extends "gameLoaded">(event: Event_4, ...args: any[]) => void;
+                clear: () => void;
+            };
+        } & import("pinia")._StoreWithState<"main", MainState, {
+            isInGame(state: {
+                ready: boolean;
+                playing: boolean;
+                errors: {
+                    text: string;
+                }[];
+                playTime: {
+                    start: number;
+                    previousPlaytime: number;
+                };
+                saveSlot: string;
+                options: {
+                    baseAssetsPath: string;
+                    baseDataPath: string;
+                    charactersPath: string;
+                    configPath: string;
+                    logging: boolean;
+                    debug: boolean;
+                };
+                flowState: 'engine-splash' | 'game-splash' | 'menu' | 'playing';
+                modal: string | false;
+                paused: boolean;
+                loading: {
+                    step: string;
+                    percentage: number;
+                    loaded: boolean;
+                };
+                alerts: {
+                    title: string;
+                    text: string;
+                    resolver: () => void;
+                    id: string;
+                }[];
+                saving: {
+                    withPrompt?: boolean | undefined;
+                    name?: string | undefined;
+                    resolver: () => void;
+                } | null;
+                saveData?: {
+                    version: string;
+                    skills: {
+                        skillChecks: {
+                            [key: string]: import("./skills").SkillCheckState;
+                        };
+                        skills: import("./skills").SkillsState;
+                    };
+                    screen: {
+                        layers: string[];
+                        buttons: import("./screens-store").ButtonsState;
+                    };
+                    main: {
+                        playTime: number;
+                    };
+                    dialog: {
+                        dialog: {
+                            speaker: string;
+                            text: string;
+                            pose?: string | undefined;
+                            cssClass?: string | undefined;
+                            choices?: {
+                                choice: string;
+                                originalIndex: number;
+                                allowed: boolean;
+                            }[] | undefined;
+                            textField?: boolean | undefined;
+                            interactive: boolean;
+                            id: string;
+                        }[];
+                    };
+                    vm: {
+                        lastLabel: string;
+                        data: import("./vm-store").DataState;
+                    };
+                    audio: {
+                        modes: {
+                            [key: string]: import("./audio-store").AudioModeState;
+                        };
+                        masterVolume: number;
+                    };
+                    hud: {
+                        hudStats: import("./hud-stats-store").HudStatsState;
+                    };
+                    inventory: {
+                        items: {
+                            [key: string]: import("./inventory-store").ItemState;
+                        };
+                        interactionTags: {
+                            [key: string]: {
+                                blockedInteraction: boolean;
+                            };
+                        };
+                    };
+                    quests: {
+                        quests: {
+                            [key: string]: import("./quest-log").QuestState;
+                        };
+                    };
+                    metadata: {
+                        saveDate: string;
+                        name: string;
+                        slotType: "manual" | "auto";
+                        id: string;
+                        createdCounter: number;
+                    };
+                } | undefined;
+                listener: {
+                    listeners: {
+                        gameLoaded: Set<() => void>;
+                    };
+                    on: <Event_1 extends "gameLoaded">(event: Event_1, listener: MainEvents[Event_1]) => MainEvents[Event_1];
+                    off: <Event_2 extends "gameLoaded">(event: Event_2, listener: MainEvents[Event_2]) => MainEvents[Event_2];
+                    once: <Event_3 extends "gameLoaded">(event: Event_3, listener: MainEvents[Event_3]) => MainEvents[Event_3];
+                    emit: <Event_4 extends "gameLoaded">(event: Event_4, ...args: any[]) => void;
+                    clear: () => void;
+                };
+            } & import("pinia").PiniaCustomStateProperties<MainState>): boolean;
+        }, any> & import("pinia")._StoreWithGetters<{
+            isInGame(state: {
+                ready: boolean;
+                playing: boolean;
+                errors: {
+                    text: string;
+                }[];
+                playTime: {
+                    start: number;
+                    previousPlaytime: number;
+                };
+                saveSlot: string;
+                options: {
+                    baseAssetsPath: string;
+                    baseDataPath: string;
+                    charactersPath: string;
+                    configPath: string;
+                    logging: boolean;
+                    debug: boolean;
+                };
+                flowState: 'engine-splash' | 'game-splash' | 'menu' | 'playing';
+                modal: string | false;
+                paused: boolean;
+                loading: {
+                    step: string;
+                    percentage: number;
+                    loaded: boolean;
+                };
+                alerts: {
+                    title: string;
+                    text: string;
+                    resolver: () => void;
+                    id: string;
+                }[];
+                saving: {
+                    withPrompt?: boolean | undefined;
+                    name?: string | undefined;
+                    resolver: () => void;
+                } | null;
+                saveData?: {
+                    version: string;
+                    skills: {
+                        skillChecks: {
+                            [key: string]: import("./skills").SkillCheckState;
+                        };
+                        skills: import("./skills").SkillsState;
+                    };
+                    screen: {
+                        layers: string[];
+                        buttons: import("./screens-store").ButtonsState;
+                    };
+                    main: {
+                        playTime: number;
+                    };
+                    dialog: {
+                        dialog: {
+                            speaker: string;
+                            text: string;
+                            pose?: string | undefined;
+                            cssClass?: string | undefined;
+                            choices?: {
+                                choice: string;
+                                originalIndex: number;
+                                allowed: boolean;
+                            }[] | undefined;
+                            textField?: boolean | undefined;
+                            interactive: boolean;
+                            id: string;
+                        }[];
+                    };
+                    vm: {
+                        lastLabel: string;
+                        data: import("./vm-store").DataState;
+                    };
+                    audio: {
+                        modes: {
+                            [key: string]: import("./audio-store").AudioModeState;
+                        };
+                        masterVolume: number;
+                    };
+                    hud: {
+                        hudStats: import("./hud-stats-store").HudStatsState;
+                    };
+                    inventory: {
+                        items: {
+                            [key: string]: import("./inventory-store").ItemState;
+                        };
+                        interactionTags: {
+                            [key: string]: {
+                                blockedInteraction: boolean;
+                            };
+                        };
+                    };
+                    quests: {
+                        quests: {
+                            [key: string]: import("./quest-log").QuestState;
+                        };
+                    };
+                    metadata: {
+                        saveDate: string;
+                        name: string;
+                        slotType: "manual" | "auto";
+                        id: string;
+                        createdCounter: number;
+                    };
+                } | undefined;
+                listener: {
+                    listeners: {
+                        gameLoaded: Set<() => void>;
+                    };
+                    on: <Event_1 extends "gameLoaded">(event: Event_1, listener: MainEvents[Event_1]) => MainEvents[Event_1];
+                    off: <Event_2 extends "gameLoaded">(event: Event_2, listener: MainEvents[Event_2]) => MainEvents[Event_2];
+                    once: <Event_3 extends "gameLoaded">(event: Event_3, listener: MainEvents[Event_3]) => MainEvents[Event_3];
+                    emit: <Event_4 extends "gameLoaded">(event: Event_4, ...args: any[]) => void;
+                    clear: () => void;
+                };
+            } & import("pinia").PiniaCustomStateProperties<MainState>): boolean;
+        }> & import("pinia").PiniaCustomProperties<string, import("pinia").StateTree, import("pinia")._GettersTree<import("pinia").StateTree>, import("pinia")._ActionsTree>;
+        screens: import("pinia").Store<"screens", import("./screens-store").ScreenState, {}, {
+            setScreen(screen: string, layer: number, transition?: import("../utils/transition").AddTransition | undefined): Promise<void>;
+            finishTransition(layer: number): void;
+            transitionScreen(screen: string, transition: import("../utils/transition").AddTransition, layer?: number | undefined): Promise<void>;
+            emptyLayer(layer: number): void;
+            setButtons(config: import("../config").Config): void;
+            changeButton(button: string, newValue: import("./screens-store").ButtonStateValue): void;
+            generateSaveData(): import("./screens-store").ScreenSave;
+            loadSaveData(data: import("./screens-store").ScreenSave): void;
+        }>;
+        skills: import("pinia").Store<"skills", import("./skills").Skills, {}, {
+            setupSkillCheck(skillCheck: import("./skills").SkillCheckState, id: string): void;
+            passSkillCheck(skillCheckId: string, hide?: boolean | undefined): void;
+            failSkillCheck(skillCheckId: string, hide?: boolean | undefined): void;
+            generateSaveData(): import("./skills").Skills;
+            getSkillCheck(id: string): import("./skills").SkillCheckState;
+            createSkillCheckState(): import("./skills").SkillCheckState;
+            loadSaveData(data: import("./skills").Skills): void;
+            setupSkills(skills: {
+                [key: string]: import("../config").SkillData;
+            }): void;
+            getSkill(skill: string): import("./skills").SkillState;
+            getSkillLevel(skill: string): number;
+            getSkillXp(skill: string): number;
+            addXp(skill: string, xp: number): void;
+            setSkillLevel(skill: string, level: number): void;
+            incrementSkill(skill: string, amount: number): void;
+            levelledUp(skill: string): void;
+        }>;
+        dialog: import("pinia").Store<"dialog", {
+            dialog: import("./dialog-store").DialogKey[];
+        }, {
+            currentDialog(): import("./dialog-store").DialogKey;
+        }, {
+            generateSaveData(): {
+                dialog: import("./dialog-store").DialogKey[];
+            };
+            loadSaveData(data: {
+                dialog: import("./dialog-store").DialogKey[];
+            }): void;
+            addDialog(dialog: import("./dialog-store").AddDialogParams): void;
+            clearDialog(): void;
+            reset(): void;
+        }>;
+        vm: import("pinia").Store<"vm", import("./vm-store").VMState, {
+            currentFrame(state: {
+                commandsWaitingForPlayerAnswer: {
+                    args: (import("../types/parser").Parser.Primitive | {
+                        code: string;
+                        command: {
+                            commandType: string;
+                            operator: string;
+                            args: (import("../types/parser").Parser.Primitive | any)[];
+                            options: import("../types/parser").Parser.DefaultArg;
+                            staticOptions: {};
+                        };
+                        fileName: string;
+                        line: number;
+                    })[];
+                    commandType: string;
+                    options: any;
+                    code: string;
+                    staticOptions: any;
+                    operator: string;
+                    line: number;
+                    fileName: string;
+                    finishCommand?: ((res: any) => void) | undefined;
+                }[];
+                stack: {
+                    blocks: {
+                        currentIndex: number;
+                        branchData: {
+                            branch: {
+                                code: string;
+                                command: {
+                                    commandType: string;
+                                    operator: string;
+                                    args: (import("../types/parser").Parser.Primitive | any)[];
+                                    options: import("../types/parser").Parser.DefaultArg;
+                                    staticOptions: {};
+                                };
+                                fileName: string;
+                                line: number;
+                            }[];
+                            args?: string[] | undefined;
+                        };
+                    }[];
+                    label: string;
+                    scope: {
+                        [key: string]: any;
+                    };
+                    returnValue: any;
+                }[];
+                script: import("../types/parser").Parser.ParsedScript;
+                data: import("./vm-store").DataState;
+                lastLabel: string;
+                jumpTarget?: {
+                    currentIndex: number;
+                    branchData: {
+                        branch: {
+                            code: string;
+                            command: {
+                                commandType: string;
+                                operator: string;
+                                args: (import("../types/parser").Parser.Primitive | any)[];
+                                options: import("../types/parser").Parser.DefaultArg;
+                                staticOptions: {};
+                            };
+                            fileName: string;
+                            line: number;
+                        }[];
+                        args?: string[] | undefined;
+                    };
+                    label: string;
+                    scope?: {
+                        [key: string]: any;
+                    } | undefined;
+                    args?: any[] | undefined;
+                } | undefined;
+                hasJumped: boolean;
+            } & import("pinia").PiniaCustomStateProperties<import("./vm-store").VMState>): import("./vm-store").MachineFrame | undefined;
+            scope(): {
+                [key: string]: any;
+            };
+            currentBlock(): import("./vm-store").MachineBlock | undefined;
+            currentLine(): import("../types/parser").Parser.ParsedExpression<import("../types/parser").Parser.DefaultArg, {}> | undefined;
+            commandWaitingForAnswer(): import("../types/parser").Parser.Command<any, any> | undefined;
+        }, {
+            generateSaveData(): import("./vm-store").VMSave;
+            loadSaveData(data: import("./vm-store").VMSave): void;
+            setReturnValue(value: any): void;
+            waitForPlayerAnswer(cmd: import("../types/parser").Parser.Command<any, any>): void;
+            popAnswerQueue(): {
+                args: (import("../types/parser").Parser.Primitive | {
+                    code: string;
+                    command: {
+                        commandType: string;
+                        operator: string;
+                        args: (import("../types/parser").Parser.Primitive | any)[];
+                        options: import("../types/parser").Parser.DefaultArg;
+                        staticOptions: {};
+                    };
+                    fileName: string;
+                    line: number;
+                })[];
+                commandType: string;
+                options: any;
+                code: string;
+                staticOptions: any;
+                operator: string;
+                line: number;
+                fileName: string;
+                finishCommand?: ((res: any) => void) | undefined;
+            } | undefined;
+            addScopedVariable(key: string, value: any): void;
+            loadScripts(scriptPaths: string[]): Promise<void>;
+            start(): void;
+            setLastLabel(label: string): void;
+            reset(): void;
+            setScript(script: import("../types/parser").Parser.ParsedScript): void;
+            overrideData(data: import("./vm-store").DataState): void;
+            setStack(stack: import("./vm-store").SetFrameOptions): void;
+            frameOptionsToFrame(frame: import("./vm-store").SetFrameOptions): import("./vm-store").MachineFrame;
+            addBlock(frame: import("./vm-store").MachineFrame, block: import("./vm-store").MachineBlock): void;
+            addAndRunBlock(block: import("./vm-store").MachineBlock): Promise<any>;
+            setData(path: string, value: any): void;
+            addInstruction(path: string, value: any): void;
+            addFrame(newStackOptions: import("./vm-store").AddFrameOptions): void;
+            addAndRunFrame(newStackOptions: import("./vm-store").AddFrameOptions): Promise<any>;
+            runFrame(): Promise<any>;
+            cleanFrame(): any;
+            runBlock(): Promise<any>;
+            cleanBlock(): void;
+            runGame(): Promise<void>;
+            nextLineOnly(): Promise<boolean>;
+            isBlockFinished(): boolean;
+            reachedEndOfScript(): void;
+            runLineOnly(): Promise<any>;
+            runLabelFunction(label: string, ...args: any[]): Promise<any>;
+            runCustomFrame(stack: import("./vm-store").AddFrameOptions): void;
+            jumpToLabel(label: string, ...args: any[]): Promise<void>;
+            runThenGoBackToPreviousDialog(label: string, ...args: any[]): Promise<any>;
+        }>;
+        hud: import("pinia").Store<"hud", import("./hud-stats-store").HudState, {}, {
+            setupHudStats(stats: {
+                [key: string]: import("../config").HudStatConfig;
+            }): void;
+            setStat(stat: string, value: number): void;
+            addStat(stat: string, value: number): void;
+            getStat(stat: string): import("./hud-stats-store").HudStat;
+            getStatValue(stat: string): number;
+            generateSaveData(): import("./hud-stats-store").HudState;
+            loadSaveData(data: import("./hud-stats-store").HudState): void;
+        }>;
+        audio: import("pinia").Store<"audio", import("./audio-store").AudioState, {}, {
+            stopAll(): void;
+            stopChannel(mode: "sound" | "music" | "ambiant", channelIndex: number): Promise<void>;
+            pauseChannel(mode: "sound" | "music" | "ambiant", channelIndex: number): Promise<void>;
+            playChannel(mode: "sound" | "music" | "ambiant", audio: string, channelIndex: number): Promise<void>;
+            changeChannel(mode: "sound" | "music" | "ambiant", audio: string, channelIndex: number): Promise<void>;
+            actuallyStopChannel(channel: import("./audio-store").AudioChannel): void;
+            getAudioChannel(mode: "sound" | "music" | "ambiant", channelIndex: number): import("./audio-store").AudioChannel | null;
+            setAudioChannel(mode: "sound" | "music" | "ambiant", channelIndex: number, value: import("./audio-store").AudioChannel | null): void;
+            actuallyPlayChannel(mode: "sound" | "music" | "ambiant", channelIndex: number, audio: string): Promise<void>;
+            reloadAudio(save: import("./audio-store").AudioSave): void;
+            stopSound(key: string): void;
+            generateSaveData(): import("./audio-store").AudioSave;
+            loadSaveData(data: import("./audio-store").AudioSave): void;
+            reset(): void;
+            setModeVolume(mode: "sound" | "music" | "ambiant", volume: number): void;
+            setMasterVolume(volume: number): void;
+            modeVolume(mode: "sound" | "music" | "ambiant"): number;
+        }>;
+        rendering: import("pinia").Store<"rendering", import("./rendering-store").RenderingState, {}, {
+            updateScreenSize(width: number, height: number, textWidth: number): void;
+        }>;
+        notifications: import("pinia").Store<"notifications", import("./notification-store").NotificationsState, {}, {
+            addNotification(text: string): Promise<void>;
+            deleteNotification(id: string): void;
+            disableNotifications(): void;
+            enableNotifications(): void;
+        }>;
+        inventory: import("pinia").Store<"inventory", import("./inventory-store").InventoryState, {}, {
+            generateSaveData(): import("./inventory-store").InventoryState;
+            loadSaveData(save: import("./inventory-store").InventoryState): void;
+            setupItems(items: {
+                [key: string]: import("../config").ItemData;
+            }): void;
+            hasItem(itemId: string, amount?: number | undefined): boolean;
+            getExistingItem(id: string): import("./inventory-store").ItemState | undefined;
+            getItemAmount(id: string): number;
+            add(item: import("./inventory-store").ItemState): void;
+            enableInteraction(tag?: string | undefined): void;
+            disableInteraction(tag?: string | undefined): void;
+            onScriptStart(): void;
+            onScriptEnd(): void;
+            isInteractionTagBlocked(tag?: string | undefined): boolean;
+            remove(item: import("./inventory-store").ItemState): void;
+            deleteItem(id: string): void;
+        }>;
+        quests: import("pinia").Store<"quests", import("./quest-log").QuestLogState, {}, {
+            getQuest(questId: string): import("./quest-log").QuestState;
+            getObjective(questId: string, objectiveId: string): import("./quest-log").ObjectiveState;
+            setupQuests(quests: {
+                [key: string]: import("../config").QuestData;
+            }): void;
+            startQuest(questId: string): void;
+            startObjective(questId: string, objectiveId: string): void;
+            completeObjective(questId: string, objectiveId: string): void;
+            completeQuest(questId: string, ending?: string | undefined): void;
+            isQuestCompleted(questId: string): boolean;
+            isObjectiveCompleted(questId: string, objectiveId: string): boolean;
+            isQuestStarted(questId: string): boolean;
+            isObjectiveStarted(questId: string, objectiveId: string): boolean;
+            removeQuest(id: string): void;
+            generateSaveData(): import("./quest-log").QuestLogState;
+            loadSaveData(data: import("./quest-log").QuestLogState): void;
+        }>;
+    };
+    overrideStates(override: any): void;
+}>;
+export {};