import { S as StorageElementType, a as StorageObjectType } from './StorageElementType-C7ETezlL.cjs';
import { L as LabelIdType, D as DialogueInterface, H as HistoryStep } from './HistoryStep-WGB6nA4N.cjs';
export { P as PixivnLabelIds } from './HistoryStep-WGB6nA4N.cjs';
import { ChoiceInterface as ChoiceInterface$1 } from '@drincs/pixi-vn';
import { L as LabelRunModeType, C as CloseType } from './HistoryChoiceMenuOption-BxMSXnyI.cjs';
export { H as HistoryChoiceMenuOption, N as NarrationHistory } from './HistoryChoiceMenuOption-BxMSXnyI.cjs';
import { S as StepLabelPropsType, a as StepLabelResultType, b as StepLabelType } from './StepLabelType-CN97wZzm.cjs';
import { O as OpenedLabel } from './OpenedLabel-Cmd675NI.cjs';
import { LabelProps as LabelProps$1 } from '@drincs/pixi-vn/canvas';
import 'microdiff';

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 NarrationChoicesInterface {
    /**
     * The choices to be shown in the game.
     */
    get list(): StoredIndexedChoiceInterface[] | undefined;
    /**
     * The choices to be shown in the game.
     * @throws {PixiError} when a choice contains functions or class instances that cannot be serialized to JSON.
     */
    set list(data: StoredChoiceInterface[] | undefined);
    /**
     * Select a choice from the choice menu, and close the choice menu.
     * @param item The choice item selected by the player.
     * @param props The props to pass to the label.
     * @returns StepLabelResultType or undefined.
     * @throws {PixiError} when the choice type is not `"call"`, `"jump"`, or `"close"`.
     * @example
     * ```ts
     * narration.choices.select(item, {
     *     navigate: navigate,
     *     // your props
     *     ...item.props
     * })
     *     .then(() => {
     *         // your code
     *     })
     *     .catch((e) => {
     *         // your code
     *     })
     * ```
     */
    select<T extends {}>(item: StoredIndexedChoiceInterface, props: StepLabelPropsType<T>): Promise<StepLabelResultType>;
}

type InputInfo = {
    isRequired?: boolean;
    type?: string;
};

interface NarrationInputInterface {
    /**
     * The input value to be inserted by the player.
     */
    value: StorageElementType;
    /**
     * If true, the player must enter a value.
     */
    readonly isRequired: boolean;
    /**
     * Returns the type of input prompt requested.
     */
    readonly type: string | undefined;
    /**
     * Returns `true` if the player must enter a value.
     * @param info The input value to be inserted by the player.
     * @param defaultValue The default value to be inserted.
     */
    request(info?: Omit<InputInfo, "isRequired">, defaultValue?: StorageElementType): void;
    /**
     * Remove the input request.
     */
    removeRequest(): void;
}

interface NarrationLabelsInterface {
    /**
     * The stack of the opened labels.
     */
    readonly opened: OpenedLabel[];
    /**
     * currentLabel is the current label that occurred during the progression of the steps.
     */
    readonly current: LabelAbstract<any> | undefined;
    /**
     * Close the current label and add it to the history.
     */
    closeCurrent(): void;
    /**
     * Close all labels and add them to the history. **Attention: This method can cause an unhandled game ending.**
     */
    closeAll(): void;
}

interface NarrationQueriesInterface {
    /**
     * 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.
     * @param label The label to check.
     * @returns times a label has been opened.
     */
    timesLabelOpened(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.
     */
    timesChoiceMade(index: number): 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 for the current `step` of the `label` (default: `false`). Note: `min` and `max` affect the storage of already generated numbers.
         * @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.
     * @deprecated Use {@link labels}.opened instead.
     */
    readonly openedLabels: OpenedLabel[];
    /**
     * currentLabel is the current label that occurred during the progression of the steps.
     * @deprecated Use {@link labels}.current instead.
     */
    readonly currentLabel: LabelAbstract<any> | undefined;
    /**
     * Close the current label and add it to the history.
     * @returns
     * @deprecated Use {@link labels}.closeCurrent instead.
     */
    closeCurrentLabel(): void;
    /**
     * Close all labels and add them to the history. **Attention: This method can cause an unhandled game ending.**
     * @deprecated Use {@link labels}.closeAll instead.
     */
    closeAllLabels(): void;
    /**
     * Check if the label is already completed.
     * @param label The label to check.
     * @returns True if the label is already completed.
     * @deprecated Use {@link queries}.isLabelAlreadyCompleted instead.
     */
    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.
     * @deprecated Use {@link queries}.alreadyCurrentStepMadeChoices instead.
     */
    readonly alreadyCurrentStepMadeChoices: number[] | undefined;
    /**
     * Check if the current step is already completed.
     * @returns True if the current step is already completed.
     * @deprecated Use {@link queries}.isCurrentStepAlreadyOpened instead.
     */
    readonly isCurrentStepAlreadyOpened: boolean;
    /**
     * Get times a label has been opened
     * @returns times a label has been opened
     * @deprecated Use {@link queries}.timesLabelOpened instead.
     */
    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.
     * @deprecated Use {@link queries}.timesChoiceMade instead.
     */
    getTimesChoiceMade(index: number): number;
    /**
     * Save the current step to the history.
     */
    addCurrentStepToHistory(): void;
    /**
     * Namespace for operations on the input requested to the player.
     */
    readonly input: NarrationInputInterface;
    /**
     * Namespace for operations on the opened labels.
     */
    readonly labels: NarrationLabelsInterface;
    /**
     * Namespace for queries about the current state of the narration.
     */
    readonly queries: NarrationQueriesInterface;
    /**
     * 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
     *     })
     * ```
     * @deprecated Use {@link choices}.select instead.
     */
    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);
    /**
     * Namespace for operations on the choices to be shown in the game.
     */
    get choices(): NarrationChoicesInterface;
    /**
     * Shortcut for {@link NarrationChoicesInterface.list}.
     * @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.
     * @deprecated Use {@link input}.value instead.
     */
    inputValue: StorageElementType;
    /**
     * If true, the player must enter a value.
     * @deprecated Use {@link input}.isRequired instead.
     */
    readonly isRequiredInput: boolean;
    /**
     * Returns the type of input prompt requested.
     * @deprecated Use {@link input}.type instead.
     */
    readonly inputType: string | undefined;
    /**
     * Returns `true` if the player must enter a value.
     * @param info The input value to be inserted by the player.
     * @param defaultValue The default value to be inserted.
     * @deprecated Use {@link input}.request instead.
     */
    requestInput(info?: Omit<InputInfo, "isRequired">, defaultValue?: StorageElementType): void;
    /**
     * Remove the input request.
     * @deprecated Use {@link input}.removeRequest instead.
     */
    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 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: string, 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: string;
    /**
     * 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
     * @param stepId Id of the step
     * @return The step or undefined if it does not exist
     */
    abstract getStepById(stepId: StepIdType): StepLabelType<TProps> | undefined;
    private _onStepStart;
    get onStepStart(): ((stepId: StepIdType, label: TLabel) => void | Promise<void>) | undefined;
    private _onLoadingLabel;
    get onLoadingLabel(): ((stepId: StepIdType, label: TLabel) => void | Promise<void>) | undefined;
    private _onStepEnd;
    get onStepEnd(): ((stepId: StepIdType, label: TLabel) => void | Promise<void>) | undefined;
}

/**
 * Label is a class that contains a list of steps, which will be performed as the game continues.
 * For Ren'py this is the equivalent of a label.
 * @example
 * ```ts
 * const START_LABEL_ID = "StartLabel"
 *
 * export const startLabel = newLabel(START_LABEL_ID,
 *     [
 *         (props) => {
 *             canvas.clear()
 *             narration.dialogue = { character: liam, text: "Which test do you want to perform?" }
 *             narration.choices = [
 *                 newChoiceOption("Events Test", eventsTestLabel),
 *                 newChoiceOption("Show Image Test", showImageTest),
 *             ]
 *         },
 *         (props) => narration.jump(START_LABEL_ID, props),
 *     ]
 * )
 *
 * narration.call(StartLabel)
 * ```
 */
declare class Label<T extends {} = {}> extends LabelAbstract<Label<T>, T> {
    get stepCount(): number;
    getStepById(stepId: number): StepLabelType<T> | undefined;
    /**
     * @param id is the id of the label
     * @param steps is the list of steps that the label will perform
     * @param props is the properties of the label
     */
    constructor(id: LabelIdType, steps: StepLabelType<T>[] | (() => StepLabelType<T>[]), props?: LabelProps$1<Label<T>>);
    private _steps;
    /**
     * Get the steps of the label.
     */
    get steps(): StepLabelType<T>[];
    getStepSha(index: number): string;
}

interface ChoiceMenuOptionOptions extends Omit<ChoiceInterface$1, "text" | "label" | "type" | "props" | "closeCurrentLabel"> {
    /**
     * How the `label` will be performed. Can be `call` or `jump`.
     * @default "call"
     */
    type?: LabelRunModeType;
}
/**
 * Function to create a new choice menu option.
 * @param text The text displayed in the choice menu.
 * @param label The `label` to call when the player selects the option.
 * @param props The properties passed to the `label`. If the `label` does not require parameters, pass an empty object `{}`.
 * @param options An object with the `choice`'s options
 * @example
 * ```ts
 * newChoiceOption("Hello", HelloLabel, {})
 * ```
 */
declare function newChoiceOption<T extends StorageObjectType>(text: ChoiceInterface$1["text"], label: Label<T> | LabelAbstract<any, T> | LabelIdType, props: T, options?: ChoiceMenuOptionOptions): ChoiceOptionInterface;

interface ChoiceMenuOptionCloseOptions extends Omit<ChoiceInterface$1, "text" | "label" | "type" | "props" | "closeCurrentLabel"> {
    /**
     * IIf `true`, the current `label` will be closed.
     * @default false
     */
    closeCurrentLabel?: boolean;
}
/**
 * In addition to `newChoiceOption`, you can use `newCloseChoiceOption` to create a closing option.
 * This closes the choice menu and continues with the `steps`, without calling any `label`.
 * @param text The text displayed in the choice menu.
 * @param options An object with the `choice`'s options
 * @example
 * ```ts
 * newCloseChoiceOption("Return")
 * ```
 */
declare function newCloseChoiceOption(text: ChoiceInterface$1["text"], options?: ChoiceMenuOptionCloseOptions): CloseChoiceOptionInterface;

type LabelSteps<T extends {}> = [StepLabelType<T>, ...StepLabelType<Partial<T>>[]];

/**
 * Creates a new label and registers it in the system.
 * **This function must be called at least once at system startup to register the label, otherwise the system cannot be used.**
 * @param id A unique identifier. Used to reference the `label` in the game (must be unique).
 * @param steps An array of functions to be executed in order. To create a dynamic array.
 * @param props An object with the `label`'s options
 * @returns The created label
 */
declare function newLabel<T extends {} = {}>(id: string, steps: LabelSteps<T> | (() => LabelSteps<T>), props?: LabelProps<Label<T>>): Label<T>;

declare namespace RegisteredLabels {
    /**
     * Gets a label by its id
     * @param id The id of the label
     * @returns The label or undefined if it does not exist
     */
    function get<T = LabelAbstract<any>, T2 extends LabelIdType | string = LabelIdType>(id: T2): T | undefined;
    /**
     * Saves a label in the system
     * @param labels The label(s) to be saved
     */
    function add(...labels: LabelAbstract<any, any>[]): void;
    /**
     * Get a list of all labels registered.
     * @returns An array of labels.
     */
    function values(): LabelAbstract<any>[];
    /**
     * Check if a label is registered
     * @param id The id of the label
     * @returns True if the label is registered, false otherwise
     */
    function has(id: string): boolean;
    /**
     * Get a list of all label ids registered.
     * @returns An array of label ids.
     */
    function keys(): LabelIdType[];
    /**
     * Removes all registered labels.
     */
    function clear(): void;
}

interface ChoiceInterface {
    /**
     * Text to be displayed in the menu
     */
    text: string | string[];
    /**
     * Label Id to be opened when the option is selected
     */
    label: LabelIdType | CloseType;
    /**
     * Type of the label to be opened
     */
    type: LabelRunModeType | CloseType;
    /**
     * If this is true, the choice can only be made once.
     */
    oneTime?: boolean;
    /**
     * If this is true, the choice can see only if there are no other choices. For example, all choices are one-time choices and they are already selected.
     */
    onlyHaveNoChoice?: boolean;
    /**
     * If this is true and if is the only choice, it will be automatically selected, and call/jump to the label.
     */
    autoSelect?: boolean;
    /**
     * If true, the current label will be closed
     */
    closeCurrentLabel?: boolean;
    /**
     * Properties to be passed to the label and olther parameters that you can use when get all the choice menu options.
     */
    props?: StorageObjectType;
}

/**
 * Interface exported step data
 */
interface NarrationGameState {
    openedLabels: OpenedLabel[];
    stepCounter: number;
}

/**
 * StepLabelPropsType is the type of the props that will be passed to the StepLabel.
 * You can override this interface to add your own props.
 * @default {}
 * @example
 * ```ts
 * // pixi-vn.d.ts
 * declare module '@drincs/pixi-vn' {
 *     interface StepLabelProps {
 *         navigate: (route: string) => void,
 *         [key: string]: any
 *     }
 * }
 * ```
 */
interface StepLabelProps {
}

/**
 * StepLabelResultType is the return type of the StepLabel function.
 * It can be useful for returning to the information calling function to perform other operations that cannot be performed within the StepLabel.
 * You can override this interface to add your own return types.
 * @default {}
 * @example
 * ```ts
 * // pixi-vn.d.ts
 * declare module '@drincs/pixi-vn' {
 *     interface StepLabelResult {
 *         newRoute?: string,
 *         [key: string]: any
 *     }
 * }
 * ```
 */
interface StepLabelResult {
}

type ChoicesMadeType = {
    /**
     * The label id of the current step.
     */
    labelId: LabelIdType;
    /**
     * The index of the step in the history.
     */
    stepIndex: number;
    /**
     * The index of the choice made by the player.
     */
    choiceIndex: number;
    /**
     * The sha1 of the step function.
     */
    stepSha1: string;
    /**
     * The number of times the player made a choice for this step.
     */
    madeTimes: number;
};

type AllOpenedLabelsType = {
    [key: LabelIdType]: {
        biggestStep: number;
        openCount: number;
    };
};
type CurrentStepTimesCounterMemotyData = {
    stepCounters?: number[];
    usedRandomNumbers?: {
        [minmaxkey: string]: number[];
    };
    stepSha1: string;
};
declare class NarrationManagerStatic {
    private constructor();
    static choiceMadeTemp: undefined | number;
    static lastHistoryStep: Omit<HistoryStep, "diff"> | null;
    /**
     * is a list of all labels that have been opened during the progression of the steps.
     * the key is the label id and the biggest step opened.
     */
    static get allOpenedLabels(): AllOpenedLabelsType;
    static set allOpenedLabels(value: AllOpenedLabelsType);
    static getCurrentStepTimesCounterData(nestedId?: string): CurrentStepTimesCounterMemotyData | null;
    private static setCurrentStepTimesCounterData;
    static getCurrentStepTimesCounter(nestedId?: string): number;
    static getRandomNumber(min: number, max: number, options?: {
        onceOnly?: boolean;
        nestedId?: string;
    }): number | undefined;
    static resetCurrentStepTimesCounter(nestedId?: string): void;
    /**
     * is a list of all choices made by the player during the progression of the steps.
     */
    static get allChoicesMade(): ChoicesMadeType[];
    static set allChoicesMade(value: ChoicesMadeType[]);
    static _stepCounter: number;
    /**
     * Increase the last step index that occurred during the progression of the steps.
     */
    static increaseStepCounter(): void;
    private static _openedLabels;
    static get openedLabels(): OpenedLabel[];
    static set openedLabels(value: OpenedLabel[]);
    private static _originalOpenedLabels;
    static get originalOpenedLabels(): OpenedLabel[];
    static set originalOpenedLabels(value: OpenedLabel[]);
    static get _currentLabel(): Label | undefined;
    /**
     * currentLabelId is the current label id that occurred during the progression of the steps.
     */
    static get currentLabelId(): LabelIdType | undefined;
    static get currentLabelStepIndex(): number | null;
    /**
     * Add a label to the history.
     * @param label The label to add to the history.
     * @param stepIndex The step index of the label.
     */
    static addLabelHistory(label: LabelIdType, stepIndex: number): void;
    static addChoicesMade(label: LabelIdType, stepIndex: number, stepSha: string, choiceMade: number): void;
    /**
     * Add a label to the history.
     * @param label The label to add to the history.
     * @throws {PixiError} when the label is not found in the registered labels.
     */
    static pushNewLabel(label: LabelIdType): void;
    /**
     * Increase the current step index of the current label.
     */
    static increaseCurrentStepIndex(): void;
    private static _onStepStart?;
    static set onStepStart(value: (stepId: number, label: LabelAbstract<any>) => void | Promise<void>);
    static get onStepStart(): ((stepId: number, label: LabelAbstract<any>) => Promise<void[]>) | undefined;
    static onLoadingLabel?: (stepId: number, label: LabelAbstract<any>) => void | Promise<void>;
    static onStepEnd?: (stepId: number, label: LabelAbstract<any>) => void | Promise<void>;
    /**
     * Is a function that will be executed every time a label is about to be started, either via
     * `call` or `jump` (this includes labels started through a choice of type `"call"` or `"jump"`).
     *
     * By default (when this is not set), the label is started immediately, exactly like before this
     * hook existed. If you set it, you take control: call `defaultStart()` yourself whenever you want
     * the label to actually run (right away, or later, e.g. from a subsequent `next()`-like action in
     * your template). Until `defaultStart()` is called, nothing about the label happens: it is not
     * added to the history and no step of it runs.
     */
    static onLabelStarting?: (labelId: LabelIdType, props: StepLabelPropsType, options: {
        choiceMade?: number;
        closeCurrentLabel?: boolean;
        type: string;
    }, defaultStart: () => Promise<StepLabelResultType>) => StepLabelResultType | Promise<StepLabelResultType>;
    /**
     * Is a function that will be executed every time the current label is about to close because it
     * naturally ran out of steps - either control is returning to the label that called it, or, if
     * there's no parent label left on the stack, the game is about to end (see {@link Game.onEnd}).
     *
     * By default (when this is not set), the label is closed immediately, exactly like before this
     * hook existed. If you set it, you take control: call `defaultClose()` yourself whenever you want
     * the label to actually close (right away, or later, e.g. from a subsequent `next()`-like action in
     * your template). Until `defaultClose()` is called, the label stays open: it is not popped off the
     * opened labels stack, narration does not continue into the parent label, and the game does not end
     * even if this was the last label - this is what lets an app show the final paragraph of a story
     * before actually ending it, instead of both happening within the same `continue()` call.
     *
     * This does not fire for a `jump` or a choice's `closeCurrentLabel` option - those close the
     * current label explicitly as part of starting a new one, so {@link onLabelStarting} already
     * covers deferring them.
     */
    static onLabelClosing?: (labelId: LabelIdType, props: StepLabelPropsType, defaultClose: () => Promise<StepLabelResultType>) => StepLabelResultType | Promise<StepLabelResultType>;
}

declare const narration: NarrationManagerInterface;

export { type ChoiceInterface, type ChoiceOptionInterface, type CloseChoiceOptionInterface, DialogueInterface, HistoryStep, type InputInfo, Label, LabelAbstract, LabelIdType, type LabelProps, LabelRunModeType, type LabelSteps, type NarrationChoicesInterface, type NarrationGameState, type NarrationInputInterface, type NarrationLabelsInterface, type NarrationManagerInterface, NarrationManagerStatic, type NarrationQueriesInterface, OpenedLabel, RegisteredLabels, type StepLabelProps, StepLabelPropsType, type StepLabelResult, StepLabelResultType, StepLabelType, type StoredChoiceInterface, type StoredIndexedChoiceInterface, narration, newChoiceOption, newCloseChoiceOption, newLabel };