@drincs/pixi-vn 1.8.10 → 1.8.11

package/dist/narration.d.cts

@@ -1,125 +1,396 @@
-import { LabelProps as LabelProps$1, NarrationManagerInterface as NarrationManagerInterface$1 } from '@drincs/pixi-vn/canvas';
+import { S as StorageElementType, a as StorageObjectType } from './StorageElementType-C7ETezlL.cjs';
+import { L as LabelIdType, D as DialogueInterface, H as HistoryStep } from './HistoryStep-DtOryKAZ.cjs';
 import { ChoiceInterface as ChoiceInterface$1 } from '@drincs/pixi-vn';
-import { a as StorageObjectType, S as StorageElementType } from './StorageElementType-C7ETezlL.cjs';
 import { L as LabelRunModeType, C as CloseType } from './HistoryChoiceMenuOption-CEmjDDJH.cjs';
 export { H as HistoryChoiceMenuOption, N as NarrationHistory } from './HistoryChoiceMenuOption-CEmjDDJH.cjs';
-import { L as LabelIdType, D as DialogueInterface, H as HistoryStep } from './HistoryStep-DtOryKAZ.cjs';
-import { b as StepLabelType, S as StepLabelPropsType, a as StepLabelResultType } from './StepLabelType-CN97wZzm.cjs';
+import { S as StepLabelPropsType, a as StepLabelResultType, b as StepLabelType } from './StepLabelType-CN97wZzm.cjs';
 import { O as OpenedLabel } from './OpenedLabel-t6PvSzaL.cjs';
+import { LabelProps as LabelProps$1 } from '@drincs/pixi-vn/canvas';
 import 'microdiff';
 
-interface ChoiceOptionInterface extends Omit<ChoiceInterface$1, "label" | "type" | "closeCurrentLabel"> {
+interface NarrationManagerInterface {
     /**
-     * Label Id to be opened when the option is selected
+     * Counter of execution times of the current step. Current execution is also included. Starts from 1.
+     *
+     * **Attention**: if the step index is edited or the code of step is edited, the counter will be reset.
+     *
+     * You can restart the counter in this way:
+     * ```ts
+     * narration.currentStepTimesCounter = 0
+     * ```
      */
-    label: LabelIdType;
+    currentStepTimesCounter: number;
     /**
-     * Type of the label to be opened
+     * Get a random number between min and max.
+     * @param min The minimum number.
+     * @param max The maximum number.
+     * @param options The options.
+     * @returns The random number or undefined. If options.onceonly is true and all numbers between min and max have already been generated, it will return undefined.
      */
-    type: LabelRunModeType;
-}
-interface CloseChoiceOptionInterface extends Omit<ChoiceInterface$1, "label" | "type" | "closeCurrentLabel"> {
+    getRandomNumber(min: number, max: number, options?: {
+        /**
+         * If true, the number will be generated only once on the current step of the label.
+         * @default false
+         */
+        onceOnly?: boolean;
+    }): number | undefined;
     /**
-     * Type of the label to be opened
+     * This counter corresponds to the total number of steps that have been executed so far.
+     *
+     * **Not is the {@link history.stepsHistory}.length - 1.**
      */
-    type: CloseType;
+    readonly stepCounter: number;
     /**
-     * If true, the current label will be closed
+     * The stack of the opened labels.
      */
-    closeCurrentLabel?: boolean;
-}
-type StoredChoiceInterface = ChoiceOptionInterface | CloseChoiceOptionInterface;
-type StoredIndexedChoiceInterface = StoredChoiceInterface & {
+    readonly openedLabels: OpenedLabel[];
     /**
-     * Is the index of the choice in the menu. It is used to identify the choice when it is selected.
+     * currentLabel is the current label that occurred during the progression of the steps.
      */
-    choiceIndex: number;
-};
-
-interface LabelProps<T, StepIdType = number> {
+    readonly currentLabel: LabelAbstract<any> | undefined;
     /**
-     * A function executed before each `step`.
-     * @param stepId The index of the `step` being executed
-     * @param label The `label` containing the `step`
+     * Close the current label and add it to the history.
      * @returns
+     */
+    closeCurrentLabel(): void;
+    /**
+     * Close all labels and add them to the history. **Attention: This method can cause an unhandled game ending.**
+     */
+    closeAllLabels(): void;
+    /**
+     * Check if the label is already completed.
+     * @param label The label to check.
+     * @returns True if the label is already completed.
+     */
+    isLabelAlreadyCompleted(label: LabelIdType | LabelAbstract<any>): boolean;
+    /**
+     * Get the choices already made in the current step. **Attention**: if the choice step index is edited or the code of choice step is edited, the result will be wrong.
+     * @returns The choices already made in the current step. If there are no choices, it will return undefined.
+     */
+    readonly alreadyCurrentStepMadeChoices: number[] | undefined;
+    /**
+     * Check if the current step is already completed.
+     * @returns True if the current step is already completed.
+     */
+    readonly isCurrentStepAlreadyOpened: boolean;
+    /**
+     * Get times a label has been opened
+     * @returns times a label has been opened
+     */
+    getTimesLabelOpened(label: LabelIdType): number;
+    /**
+     * Get times a choice has been made in the current step.
+     * @param index The index of the choice.
+     * @returns The number of times the choice has been made.
+     */
+    getTimesChoiceMade(index: number): number;
+    /**
+     * Save the current step to the history.
+     */
+    addCurrentStepToHistory(): void;
+    /**
+     * Return if can go to the next step. It's `false` when:
+     * - A `step` is running
+     * - The player must "make a choice"
+     * - The player must "enter a value"
+     * @returns True if can go to the next step.
+     */
+    readonly canContinue: boolean;
+    /**
+     * Execute the next step and add it to the history. If a step is already running, it will put the request in the queue,
+     * and when the step is finished, it will execute the next step.
+     * @param props The props to pass to the step.
+     * @param options The options.
+     * @returns StepLabelResultType or undefined.
      * @example
      * ```ts
-     * const startLabel = newLabel("start", [
-     *     () => {
-     *         narration.dialogue = "Step 1"
-     *     },
-     *     () => {
-     *         narration.dialogue = "Step 2"
-     *     }
-     * ], {
-     *     onStepStart: (stepIndex, label) => {
-     *         console.log(`Step ${stepIndex} started`)
+     *     function nextOnClick() {
+     *     setLoading(true)
+     *     narration.continue(yourParams)
+     *         .then((result) => {
+     *             setUpdate((p) => p + 1)
+     *             setLoading(false)
+     *             if (result) {
+     *                 // your code
+     *             }
+     *         })
+     *         .catch((e) => {
+     *             setLoading(false)
+     *             console.error(e)
+     *         })
+     * }
+     * ```
+     */
+    continue: (props: StepLabelPropsType, options?: {
+        /**
+         * The number of steps to advance. Must be a valid finite number greater than 0.
+         * If NaN, Infinity, or a value less than or equal to 0 is provided, the implementation
+         * will emit a warning and return early without advancing steps. @default 1
+         */
+        steps?: number;
+        /**
+         * If true, ignore the running step, ignore the choice menu/required input and run the next step immediately.
+         */
+        runNow?: boolean;
+    }) => Promise<StepLabelResultType>;
+    /**
+     * Execute the label, add the label to the history and execute the next step of the label.
+     * @param label The label to execute or the id of the label
+     * @param props The props to pass to the label.
+     * @returns StepLabelResultType or undefined.
+     * @throws {PixiError} when the label is not found in the registered labels.
+     * @example
+     * ```ts
+     * narration.call(startLabel, yourParams).then((result) => {
+     *     if (result) {
+     *         // your code
      *     }
      * })
      * ```
+     * @example
+     * ```ts
+     * // if you use it in a step label you should return the result.
+     * return narration.call(startLabel).then((result) => {
+     *     return result
+     * })
+     * ```
      */
-    onStepStart?: (stepId: StepIdType, label: T) => void | Promise<void>;
+    call<T extends {} = {}>(label: LabelAbstract<any, T> | LabelIdType, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
     /**
-     * Is a function that will be executed in {@link onStepStart} if the id of the step is 0
-     * and when the user laods a save file.
-     * When you load a save file, will be executed all onLoadingLabel functions of the {@link narration.openedLabels}.
-     * It is useful for example to make sure all images used have been cached
-     * @param stepId The index of the `step` being executed
-     * @param label The `label` being executed
-     * @returns
+     * Execute the label, replace the current label in the history with the new label and execute the next step of the label.
+     * @param label The label to execute.
+     * @param props The props to pass to the label or the id of the label
+     * @returns StepLabelResultType or undefined.
+     * @throws {PixiError} when the label is not found in the registered labels.
      * @example
-     * ```ts title="content/labels/start.label.ts"
-     * newLabel("start", [], {
-     *     onLoadingLabel: async (stepId, label) => {
-     *         await Assets.load('path/to/image1.png')
-     *         await Assets.load('path/to/image2.png')
+     * ```ts
+     * narration.jump(startLabel, yourParams).then((result) => {
+     *     if (result) {
+     *         // your code
      *     }
      * })
      * ```
+     * @example
+     * ```ts
+     * // if you use it in a step label you should return the result.
+     * return narration.jump(startLabel).then((result) => {
+     *     return result
+     * })
+     * ```
      */
-    onLoadingLabel?: (stepId: StepIdType, label: T) => void | Promise<void>;
+    jump<T extends {}>(label: LabelAbstract<any, T> | LabelIdType, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
     /**
-     * A function executed after each `step`. See more <DynamicLink href="/start/labels-advanced#onstepend">here</DynamicLink>.
-     * @param stepId The index of the `step` that ended
-     * @param label The `label` containing the `step`
+     * Select a choice from the choice menu. and close the choice menu.
+     * @param item
+     * @param props
      * @returns
+     * @throws {PixiError} when the choice type is not `"call"`, `"jump"`, or `"close"`.
      * @example
      * ```ts
-     * const startLabel = newLabel("start", [
-     *     async () => {
-     *         await showImage("image1", "path/to/image1.png")
-     *         await showImage("image2", "path/to/image2.png")
-     *     }
-     * ], {
-     *     onLoadingLabel: async (stepIndex, label) => {
-     *         await Assets.load("path/to/image1.png")
-     *         await Assets.load("path/to/image2.png")
-     *     }
+     * narration.selectChoice(item, {
+     *     navigate: navigate,
+     *     // your props
+     *     ...item.props
      * })
+     *     .then(() => {
+     *         // your code
+     *     })
+     *     .catch((e) => {
+     *         // your code
+     *     })
      * ```
      */
-    onStepEnd?: (stepId: StepIdType, label: T) => void | Promise<void>;
-}
-
-declare abstract class LabelAbstract<TLabel, TProps extends {} = {}, StepIdType = number> implements LabelProps<TLabel, StepIdType> {
+    selectChoice<T extends {}>(item: StoredIndexedChoiceInterface, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
+    /** Old Step Methods */
     /**
-     * @param id is the id of the label
-     * @param props is the properties of the label
+     * Dialogue to be shown in the game
      */
-    constructor(id: LabelIdType, props?: LabelProps<TLabel, StepIdType>);
+    get dialogue(): DialogueInterface | undefined;
     /**
-     * Get the id of the label. This variable is used in the system to get the label by id, {@link RegisteredLabels.get}
+     * Dialogue to be shown in the game
+     * @throws {PixiError} when the dialogue contains functions or class instances that cannot be serialized to JSON.
      */
-    readonly id: LabelIdType;
+    set dialogue(props: DialogueInterface | string | string[] | undefined);
     /**
-     * Get the number of steps in the label. This variable is used in the system to get the number of steps in the label.
-     * @returns The number of steps in the label
+     * The options to be shown in the game
+     * @example
+     * ```ts
+     * narration.choices = [
+     *     newChoiceOption("Events Test", EventsTestLabel, {}),
+     *     newChoiceOption("Show Image Test", ShowImageTest, { image: "imageId" }, "call"),
+     *     newChoiceOption("Ticker Test", TickerTestLabel, {}),
+     *     newChoiceOption("Tinting Test", TintingTestLabel, {}, "jump"),
+     *     newChoiceOption("Base Canvas Element Test", BaseCanvasElementTestLabel, {})
+     * ]
+     * ```
      */
-    abstract get stepCount(): number;
+    get choices(): StoredIndexedChoiceInterface[] | undefined;
     /**
-     * Get the sha of the step
-     * @param index Index of the step
-     */
+     * The options to be shown in the game
+     * @throws {PixiError} when a choice contains functions or class instances that cannot be serialized to JSON.
+     * @example
+     * ```ts
+     * narration.choices = [
+     *     newChoiceOption("Events Test", EventsTestLabel, {}),
+     *     newChoiceOption("Show Image Test", ShowImageTest, { image: "imageId" }, "call"),
+     *     newChoiceOption("Ticker Test", TickerTestLabel, {}),
+     *     newChoiceOption("Tinting Test", TintingTestLabel, {}, "jump"),
+     *     newChoiceOption("Base Canvas Element Test", BaseCanvasElementTestLabel, {})
+     * ]
+     * ```
+     */
+    set choices(data: StoredChoiceInterface[] | undefined);
+    /**
+     * If true, the next dialogue text will be added to the current dialogue text.
+     */
+    dialogGlue: boolean;
+    /**
+     * The input value to be inserted by the player.
+     */
+    inputValue: StorageElementType;
+    /**
+     * If true, the player must enter a value.
+     */
+    readonly isRequiredInput: boolean;
+    readonly inputType: string | undefined;
+    /**
+     * Request input from the player.
+     * @param info The input value to be inserted by the player.
+     * @param defaultValue The default value to be inserted.
+     */
+    requestInput(info: Omit<InputInfo, "isRequired">, defaultValue?: StorageElementType): void;
+    /**
+     * Remove the input request.
+     */
+    removeInputRequest(): void;
+    /**
+     * Clear all narration data
+     */
+    clear(): void;
+    /**
+     * Export the narration to an object.
+     * @returns The narration in an object.
+     */
+    export(): NarrationGameState;
+    /**
+     * Restore the narration from an object.
+     * @param data The narration in an object.
+     */
+    restore(data: object, lastHistoryStep: Omit<HistoryStep, "diff"> | null): Promise<void>;
+}
+
+interface ChoiceOptionInterface extends Omit<ChoiceInterface$1, "label" | "type" | "closeCurrentLabel"> {
+    /**
+     * Label Id to be opened when the option is selected
+     */
+    label: LabelIdType;
+    /**
+     * Type of the label to be opened
+     */
+    type: LabelRunModeType;
+}
+interface CloseChoiceOptionInterface extends Omit<ChoiceInterface$1, "label" | "type" | "closeCurrentLabel"> {
+    /**
+     * Type of the label to be opened
+     */
+    type: CloseType;
+    /**
+     * If true, the current label will be closed
+     */
+    closeCurrentLabel?: boolean;
+}
+type StoredChoiceInterface = ChoiceOptionInterface | CloseChoiceOptionInterface;
+type StoredIndexedChoiceInterface = StoredChoiceInterface & {
+    /**
+     * Is the index of the choice in the menu. It is used to identify the choice when it is selected.
+     */
+    choiceIndex: number;
+};
+
+interface LabelProps<T, StepIdType = number> {
+    /**
+     * A function executed before each `step`.
+     * @param stepId The index of the `step` being executed
+     * @param label The `label` containing the `step`
+     * @returns
+     * @example
+     * ```ts
+     * const startLabel = newLabel("start", [
+     *     () => {
+     *         narration.dialogue = "Step 1"
+     *     },
+     *     () => {
+     *         narration.dialogue = "Step 2"
+     *     }
+     * ], {
+     *     onStepStart: (stepIndex, label) => {
+     *         console.log(`Step ${stepIndex} started`)
+     *     }
+     * })
+     * ```
+     */
+    onStepStart?: (stepId: StepIdType, label: T) => void | Promise<void>;
+    /**
+     * Is a function that will be executed in {@link onStepStart} if the id of the step is 0
+     * and when the user laods a save file.
+     * When you load a save file, will be executed all onLoadingLabel functions of the {@link narration.openedLabels}.
+     * It is useful for example to make sure all images used have been cached
+     * @param stepId The index of the `step` being executed
+     * @param label The `label` being executed
+     * @returns
+     * @example
+     * ```ts title="content/labels/start.label.ts"
+     * newLabel("start", [], {
+     *     onLoadingLabel: async (stepId, label) => {
+     *         await Assets.load('path/to/image1.png')
+     *         await Assets.load('path/to/image2.png')
+     *     }
+     * })
+     * ```
+     */
+    onLoadingLabel?: (stepId: StepIdType, label: T) => void | Promise<void>;
+    /**
+     * A function executed after each `step`. See more <DynamicLink href="/start/labels-advanced#onstepend">here</DynamicLink>.
+     * @param stepId The index of the `step` that ended
+     * @param label The `label` containing the `step`
+     * @returns
+     * @example
+     * ```ts
+     * const startLabel = newLabel("start", [
+     *     async () => {
+     *         await showImage("image1", "path/to/image1.png")
+     *         await showImage("image2", "path/to/image2.png")
+     *     }
+     * ], {
+     *     onLoadingLabel: async (stepIndex, label) => {
+     *         await Assets.load("path/to/image1.png")
+     *         await Assets.load("path/to/image2.png")
+     *     }
+     * })
+     * ```
+     */
+    onStepEnd?: (stepId: StepIdType, label: T) => void | Promise<void>;
+}
+
+declare abstract class LabelAbstract<TLabel, TProps extends {} = {}, StepIdType = number> implements LabelProps<TLabel, StepIdType> {
+    /**
+     * @param id is the id of the label
+     * @param props is the properties of the label
+     */
+    constructor(id: LabelIdType, props?: LabelProps<TLabel, StepIdType>);
+    /**
+     * Get the id of the label. This variable is used in the system to get the label by id, {@link RegisteredLabels.get}
+     */
+    readonly id: LabelIdType;
+    /**
+     * Get the number of steps in the label. This variable is used in the system to get the number of steps in the label.
+     * @returns The number of steps in the label
+     */
+    abstract get stepCount(): number;
+    /**
+     * Get the sha of the step
+     * @param index Index of the step
+     */
     abstract getStepSha(stepId: StepIdType): string | undefined;
     /**
      * Get the step by id
@@ -291,277 +562,6 @@ interface NarrationGameState {
     stepCounter: number;
 }
 
-interface NarrationManagerInterface {
-    /**
-     * Counter of execution times of the current step. Current execution is also included. Starts from 1.
-     *
-     * **Attention**: if the step index is edited or the code of step is edited, the counter will be reset.
-     *
-     * You can restart the counter in this way:
-     * ```ts
-     * narration.currentStepTimesCounter = 0
-     * ```
-     */
-    currentStepTimesCounter: number;
-    /**
-     * Get a random number between min and max.
-     * @param min The minimum number.
-     * @param max The maximum number.
-     * @param options The options.
-     * @returns The random number or undefined. If options.onceonly is true and all numbers between min and max have already been generated, it will return undefined.
-     */
-    getRandomNumber(min: number, max: number, options?: {
-        /**
-         * If true, the number will be generated only once on the current step of the label.
-         * @default false
-         */
-        onceOnly?: boolean;
-    }): number | undefined;
-    /**
-     * This counter corresponds to the total number of steps that have been executed so far.
-     *
-     * **Not is the {@link history.stepsHistory}.length - 1.**
-     */
-    readonly stepCounter: number;
-    /**
-     * The stack of the opened labels.
-     */
-    readonly openedLabels: OpenedLabel[];
-    /**
-     * currentLabel is the current label that occurred during the progression of the steps.
-     */
-    readonly currentLabel: LabelAbstract<any> | undefined;
-    /**
-     * Close the current label and add it to the history.
-     * @returns
-     */
-    closeCurrentLabel(): void;
-    /**
-     * Close all labels and add them to the history. **Attention: This method can cause an unhandled game ending.**
-     */
-    closeAllLabels(): void;
-    /**
-     * Check if the label is already completed.
-     * @param label The label to check.
-     * @returns True if the label is already completed.
-     */
-    isLabelAlreadyCompleted(label: LabelIdType | LabelAbstract<any>): boolean;
-    /**
-     * Get the choices already made in the current step. **Attention**: if the choice step index is edited or the code of choice step is edited, the result will be wrong.
-     * @returns The choices already made in the current step. If there are no choices, it will return undefined.
-     */
-    readonly alreadyCurrentStepMadeChoices: number[] | undefined;
-    /**
-     * Check if the current step is already completed.
-     * @returns True if the current step is already completed.
-     */
-    readonly isCurrentStepAlreadyOpened: boolean;
-    /**
-     * Get times a label has been opened
-     * @returns times a label has been opened
-     */
-    getTimesLabelOpened(label: LabelIdType): number;
-    /**
-     * Get times a choice has been made in the current step.
-     * @param index The index of the choice.
-     * @returns The number of times the choice has been made.
-     */
-    getTimesChoiceMade(index: number): number;
-    /**
-     * Save the current step to the history.
-     */
-    addCurrentStepToHistory(): void;
-    /**
-     * Return if can go to the next step. It's `false` when:
-     * - A `step` is running
-     * - The player must "make a choice"
-     * - The player must "enter a value"
-     * @returns True if can go to the next step.
-     */
-    readonly canContinue: boolean;
-    /**
-     * Execute the next step and add it to the history. If a step is already running, it will put the request in the queue,
-     * and when the step is finished, it will execute the next step.
-     * @param props The props to pass to the step.
-     * @param options The options.
-     * @returns StepLabelResultType or undefined.
-     * @example
-     * ```ts
-     *     function nextOnClick() {
-     *     setLoading(true)
-     *     narration.continue(yourParams)
-     *         .then((result) => {
-     *             setUpdate((p) => p + 1)
-     *             setLoading(false)
-     *             if (result) {
-     *                 // your code
-     *             }
-     *         })
-     *         .catch((e) => {
-     *             setLoading(false)
-     *             console.error(e)
-     *         })
-     * }
-     * ```
-     */
-    continue: (props: StepLabelPropsType, options?: {
-        /**
-         * The number of steps to advance. Must be a valid finite number greater than 0.
-         * If NaN, Infinity, or a value less than or equal to 0 is provided, the implementation
-         * will emit a warning and return early without advancing steps. @default 1
-         */
-        steps?: number;
-        /**
-         * If true, ignore the running step, ignore the choice menu/required input and run the next step immediately.
-         */
-        runNow?: boolean;
-    }) => Promise<StepLabelResultType>;
-    /**
-     * Execute the label, add the label to the history and execute the next step of the label.
-     * @param label The label to execute or the id of the label
-     * @param props The props to pass to the label.
-     * @returns StepLabelResultType or undefined.
-     * @throws {PixiError} when the label is not found in the registered labels.
-     * @example
-     * ```ts
-     * narration.call(startLabel, yourParams).then((result) => {
-     *     if (result) {
-     *         // your code
-     *     }
-     * })
-     * ```
-     * @example
-     * ```ts
-     * // if you use it in a step label you should return the result.
-     * return narration.call(startLabel).then((result) => {
-     *     return result
-     * })
-     * ```
-     */
-    call<T extends {} = {}>(label: LabelAbstract<any, T> | LabelIdType, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
-    /**
-     * Execute the label, replace the current label in the history with the new label and execute the next step of the label.
-     * @param label The label to execute.
-     * @param props The props to pass to the label or the id of the label
-     * @returns StepLabelResultType or undefined.
-     * @throws {PixiError} when the label is not found in the registered labels.
-     * @example
-     * ```ts
-     * narration.jump(startLabel, yourParams).then((result) => {
-     *     if (result) {
-     *         // your code
-     *     }
-     * })
-     * ```
-     * @example
-     * ```ts
-     * // if you use it in a step label you should return the result.
-     * return narration.jump(startLabel).then((result) => {
-     *     return result
-     * })
-     * ```
-     */
-    jump<T extends {}>(label: LabelAbstract<any, T> | LabelIdType, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
-    /**
-     * Select a choice from the choice menu. and close the choice menu.
-     * @param item
-     * @param props
-     * @returns
-     * @throws {PixiError} when the choice type is not `"call"`, `"jump"`, or `"close"`.
-     * @example
-     * ```ts
-     * narration.selectChoice(item, {
-     *     navigate: navigate,
-     *     // your props
-     *     ...item.props
-     * })
-     *     .then(() => {
-     *         // your code
-     *     })
-     *     .catch((e) => {
-     *         // your code
-     *     })
-     * ```
-     */
-    selectChoice<T extends {}>(item: StoredIndexedChoiceInterface, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
-    /** Old Step Methods */
-    /**
-     * Dialogue to be shown in the game
-     */
-    get dialogue(): DialogueInterface | undefined;
-    /**
-     * Dialogue to be shown in the game
-     * @throws {PixiError} when the dialogue contains functions or class instances that cannot be serialized to JSON.
-     */
-    set dialogue(props: DialogueInterface | string | string[] | undefined);
-    /**
-     * The options to be shown in the game
-     * @example
-     * ```ts
-     * narration.choices = [
-     *     newChoiceOption("Events Test", EventsTestLabel, {}),
-     *     newChoiceOption("Show Image Test", ShowImageTest, { image: "imageId" }, "call"),
-     *     newChoiceOption("Ticker Test", TickerTestLabel, {}),
-     *     newChoiceOption("Tinting Test", TintingTestLabel, {}, "jump"),
-     *     newChoiceOption("Base Canvas Element Test", BaseCanvasElementTestLabel, {})
-     * ]
-     * ```
-     */
-    get choices(): StoredIndexedChoiceInterface[] | undefined;
-    /**
-     * The options to be shown in the game
-     * @throws {PixiError} when a choice contains functions or class instances that cannot be serialized to JSON.
-     * @example
-     * ```ts
-     * narration.choices = [
-     *     newChoiceOption("Events Test", EventsTestLabel, {}),
-     *     newChoiceOption("Show Image Test", ShowImageTest, { image: "imageId" }, "call"),
-     *     newChoiceOption("Ticker Test", TickerTestLabel, {}),
-     *     newChoiceOption("Tinting Test", TintingTestLabel, {}, "jump"),
-     *     newChoiceOption("Base Canvas Element Test", BaseCanvasElementTestLabel, {})
-     * ]
-     * ```
-     */
-    set choices(data: StoredChoiceInterface[] | undefined);
-    /**
-     * If true, the next dialogue text will be added to the current dialogue text.
-     */
-    dialogGlue: boolean;
-    /**
-     * The input value to be inserted by the player.
-     */
-    inputValue: StorageElementType;
-    /**
-     * If true, the player must enter a value.
-     */
-    readonly isRequiredInput: boolean;
-    readonly inputType: string | undefined;
-    /**
-     * Request input from the player.
-     * @param info The input value to be inserted by the player.
-     * @param defaultValue The default value to be inserted.
-     */
-    requestInput(info: Omit<InputInfo, "isRequired">, defaultValue?: StorageElementType): void;
-    /**
-     * Remove the input request.
-     */
-    removeInputRequest(): void;
-    /**
-     * Clear all narration data
-     */
-    clear(): void;
-    /**
-     * Export the narration to an object.
-     * @returns The narration in an object.
-     */
-    export(): NarrationGameState;
-    /**
-     * Restore the narration from an object.
-     * @param data The narration in an object.
-     */
-    restore(data: object, lastHistoryStep: Omit<HistoryStep, "diff"> | null): Promise<void>;
-}
-
 /**
  * StepLabelPropsType is the type of the props that will be passed to the StepLabel.
  * You can override this interface to add your own props.
@@ -704,6 +704,6 @@ type InputInfo = {
     type?: string;
 };
 
-declare const narration: NarrationManagerInterface$1;
+declare const narration: NarrationManagerInterface;
 
 export { type ChoiceInterface, type ChoiceOptionInterface, type CloseChoiceOptionInterface, DialogueInterface, HistoryStep, type InputInfo, Label, LabelAbstract, type LabelProps, LabelRunModeType, type LabelSteps, type NarrationGameState, type NarrationManagerInterface, NarrationManagerStatic, OpenedLabel, RegisteredLabels, type StepLabelProps, StepLabelPropsType, type StepLabelResult, StepLabelResultType, StepLabelType, type StoredChoiceInterface, type StoredIndexedChoiceInterface, narration, newChoiceOption, newCloseChoiceOption, newLabel };