@momoyu-ink/kit 0.4.1 → 0.5.0

package/dist/lib.d.mts

@@ -0,0 +1,667 @@
+import * as React$1 from 'react';
+import React__default, { Component, ReactElement, ForwardRefExoticComponent, CSSProperties, FC } from 'react';
+import Reconciler, { BaseErrorInfo } from 'react-reconciler';
+import { N as Node, M as MouseEvent, a as MoyuEvent, C as Command, b as MaybePromise, J as JSX } from './jsx-dev-runtime--ZXLAgUi.mjs';
+export { A as AudioCommand, c as AudioSettings, B as BubbleEvent, D as DetailedMoyuProps, E as EffectParams, G as GamepadCommand, K as KeyboardEvent, d as KeyboardEventKind, e as MakeNullOptional, f as MouseEventKind, g as MoyuAnimationAttributes, h as MoyuBackdropAttributes, i as MoyuClipAttributes, j as MoyuContainerAttributes, k as MoyuEventHandler, l as MoyuFilterAttributes, m as MoyuListenerAttributes, n as MoyuNodeAttributes, o as MoyuSpriteAttributes, p as MoyuTextAttributes, q as MoyuVideoAttributes, S as ScenarioCommand, r as SystemCommand, T as TextCommand, s as TouchEvent, t as TouchEventKind, u as Tuple2, v as Tuple3, w as Tuple4, W as WindowState, x as createBubbleEvent, y as getStageSize } from './jsx-dev-runtime--ZXLAgUi.mjs';
+import { FluidValue } from '@react-spring/shared';
+import { ElementType, AssignableKeys, ComponentPropsWithRef } from '@react-spring/types';
+import { Snapshot } from 'valtio';
+import { SpringValues, SpringRef } from '@react-spring/core';
+export * from '@react-spring/core';
+import { ZodType } from 'zod';
+import 'react/jsx-runtime';
+import 'react/jsx-dev-runtime';
+
+declare const MoyuRenderer: Reconciler.Reconciler<Node, Node, never, never, never, any>;
+interface RootOptions {
+    /**
+     * Prefix for `useId`.
+     */
+    identifierPrefix?: string;
+    onUncaughtError: (error: Error, info: BaseErrorInfo & {
+        errorBoundary?: Component;
+    }) => void;
+    onCaughtError: (error: Error, info: BaseErrorInfo) => void;
+    onRecoverableError: (error: Error, info: BaseErrorInfo) => void;
+    onDefaultTransitionIndicator: () => void;
+}
+declare function createRoot(options?: RootOptions): {
+    render: (reactElement: ReactElement, callback?: (() => void) | null) => Reconciler.Lane;
+};
+
+declare const globalEventListeners: Record<string, ((event: unknown) => void)[]>;
+declare const globalRequestAnimationFrameListeners: FrameRequestCallback[];
+
+declare function addEventListener(name: string, callback: (...args: any[]) => void): () => void;
+
+interface WheelEvent extends Omit<MouseEvent, 'kind'> {
+    kind: 'wheel';
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    deltaMode: WheelEventDeltaMode;
+}
+
+type AnimationFrameCallbackEvent = {
+    timestamp: number;
+};
+
+type BeforeUnloadEvent = Record<symbol, never>;
+
+/**
+ * Custom event for user-defined events
+ */
+type CustomEvent<T> = {
+    kind: 'CustomEvent';
+    /**
+     * target node id, or 0 for global
+     */
+    targetId: number;
+    /**
+     * event name for `addEventListener` or `onXXX`
+     */
+    name: string;
+    /**
+     * event body, pass as parameter to callback
+     */
+    body?: T;
+};
+
+type FocusEventKind = 'focus' | 'blur';
+
+type FocusEvent = {
+    kind: FocusEventKind;
+    targetId: number;
+};
+
+type FullscreenEventKind = 'change' | 'error';
+
+type FullScreenEvent = {
+    kind: FullscreenEventKind;
+};
+
+type GameEvent = 'ready';
+
+/**
+ * The GamepadButton interface defines an individual button of a gamepad or other controller, allowing
+ * access to the current state of different types of buttons available on the control device.
+ */
+type GamepadButton = {
+    /**
+     * A boolean value indicating whether the button is currently pressed (`true`) or unpressed (`false`).
+     */
+    pressed: boolean;
+    /**
+     * A boolean value indicating whether the button is currently touched (`true`) or not touched (`false`).
+     */
+    touched: boolean;
+    /**
+     * A double value used to represent the current state of analog buttons, such as the triggers on many
+     * modern gamepads. The values are normalized to the range 0.0 — 1.0, with 0.0 representing a button that
+     * is not pressed, and 1.0 representing a button that is fully pressed.
+     */
+    value: number;
+};
+
+/**
+ * The GamepadHapticActuator interface of the [Gamepad API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API)
+ * represents hardware in the controller designed to provide haptic feedback to the user (if available),
+ * most commonly vibration hardware.
+ */
+type GamepadHapticActuator = {
+    /**
+     * Returns an array of enumerated values representing the different haptic effects that the actuator supports.
+     */
+    effects: Array<string>;
+};
+
+/**
+ * The Gamepad interface of the [Gamepad API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API)
+ * defines an individual gamepad or other controller, allowing access to information such as button presses,
+ * axis positions, and id.
+ */
+type Gamepad = {
+    /**
+     * A string containing identifying information about the controller.
+     */
+    id: string;
+    /**
+     * An integer that is auto-incremented to be unique for each device currently connected to the system.
+     */
+    index: number;
+    /**
+     * A boolean indicating whether the gamepad is still connected to the system.
+     */
+    connected: boolean;
+    /**
+     * A string indicating whether the browser has remapped the controls on the device to a known layout.
+     * Currently, the only value that is returned is "standard", which indicates that the browser has
+     * remapped the controls to a standard layout.
+     * See [gamepad#remapping](https://w3c.github.io/gamepad/#remapping)
+     */
+    mapping: string;
+    /**
+     * An array of [GamepadButton] objects representing the buttons present on the device.
+     */
+    buttons: Array<GamepadButton>;
+    /**
+     * An array representing the controls with axes present on the device (e.g. analog thumb sticks).
+     */
+    axes: Array<number>;
+    /**
+     * A GamepadHapticActuator object, which represents haptic feedback hardware available on the controller.
+     */
+    vibrationActuator: GamepadHapticActuator | null;
+    /**
+     * A f64 representing the last time the data for this gamepad was updated.
+     */
+    timestamp: number;
+};
+
+type GamepadEvent = {
+    gamepad: Gamepad;
+} | {
+    gamepad: Gamepad;
+    button: GamepadButton;
+} | {
+    gamepad: Gamepad;
+    axis: number;
+    value: number;
+};
+
+type KeyboardLocation = 'Standard' | 'Left' | 'Right' | 'Numpad';
+
+type Literal = null | string | bigint | number | boolean | Array<Literal> | {
+    [key in string]: Literal;
+};
+
+type NodeEvent = {
+    kind: 'Destory';
+    targetId: number;
+};
+
+type ResizeEvent = {
+    width: number;
+    height: number;
+};
+
+type ResolvedArgument = {
+    name: string;
+    value: Literal;
+};
+
+type ResolvedCommandLine = {
+    command: string;
+    arguments: Array<ResolvedArgument>;
+};
+
+type ResolvedSystemCallLine = {
+    command: string;
+    arguments: Array<ResolvedArgument>;
+};
+
+type TextLine = {
+    leading: string | null;
+    text: string | null;
+    tailing: string | null;
+};
+
+type ScenarioEvent = ResolvedCommandLine | ResolvedSystemCallLine | TextLine | null;
+
+type TextEvent = null | number;
+
+type WheelEventDeltaMode = 'pixel' | 'line' | 'page';
+
+declare global {
+    interface Window {
+        moyu: any;
+    }
+    var __moyu_receive_event: (event: MoyuEvent) => void;
+    var __moyu_eval_sandbox: (code: string) => any;
+}
+declare function createInstance(nodeType: string, label: string | undefined, props: Record<string, any>): number;
+declare function destroyInstance(nodeId: number): void;
+declare function addChild(nodeId: number, childNodeId: number): void;
+declare function insertChild(nodeId: number, index: number, childNodeId: number): void;
+declare function insertChildBefore(nodeId: number, beforeChildNodeId: number, childNodeId: number): void;
+declare function removeChildAt(nodeId: number, index: number): void;
+declare function removeChild(nodeId: number, childNodeId: number): void;
+declare function updateProps(nodeId: number, props: Record<string, any>): void;
+declare function executeNodeCommand(nodeId: number, payload: Command): MaybePromise;
+declare function executePluginCommand(pluginName: string, payload: Command): MaybePromise;
+
+declare const moyu_addChild: typeof addChild;
+declare const moyu_createInstance: typeof createInstance;
+declare const moyu_destroyInstance: typeof destroyInstance;
+declare const moyu_executeNodeCommand: typeof executeNodeCommand;
+declare const moyu_executePluginCommand: typeof executePluginCommand;
+declare const moyu_insertChild: typeof insertChild;
+declare const moyu_insertChildBefore: typeof insertChildBefore;
+declare const moyu_removeChild: typeof removeChild;
+declare const moyu_removeChildAt: typeof removeChildAt;
+declare const moyu_updateProps: typeof updateProps;
+declare namespace moyu {
+  export { moyu_addChild as addChild, moyu_createInstance as createInstance, moyu_destroyInstance as destroyInstance, moyu_executeNodeCommand as executeNodeCommand, moyu_executePluginCommand as executePluginCommand, moyu_insertChild as insertChild, moyu_insertChildBefore as insertChildBefore, moyu_removeChild as removeChild, moyu_removeChildAt as removeChildAt, moyu_updateProps as updateProps };
+}
+
+type Primitives = keyof JSX.IntrinsicElements;
+
+type AnimatedPrimitives = {
+    [P in Primitives]: AnimatedComponent<FC<JSX.IntrinsicElements[P]>>;
+};
+/** The type of the `animated()` function */
+type WithAnimated = (<T extends ElementType>(wrappedComponent: T) => AnimatedComponent<T>) & AnimatedPrimitives;
+/** The type of an `animated()` component */
+type AnimatedComponent<T extends ElementType> = ForwardRefExoticComponent<AnimatedProps<ComponentPropsWithRef<T>>>;
+/** The props of an `animated()` component */
+type AnimatedProps<Props extends object> = {
+    [P in keyof Props]: P extends 'ref' | 'key' ? Props[P] : AnimatedProp<Props[P]>;
+};
+type AnimatedProp<T> = [T, T] extends [infer T, infer DT] ? [DT] extends [never] ? never : DT extends void ? undefined : DT extends object ? [AssignableKeys<DT, CSSProperties>] extends [never] ? DT extends ReadonlyArray<any> ? AnimatedStyles<DT> : DT : AnimatedStyle<T> : DT | AnimatedLeaf<T> : never;
+type AnimatedStyles<T extends ReadonlyArray<any>> = {
+    [P in keyof T]: [T[P]] extends [infer DT] ? DT extends object ? [AssignableKeys<DT, CSSProperties>] extends [never] ? DT extends ReadonlyArray<any> ? AnimatedStyles<DT> : DT : {
+        [P in keyof DT]: AnimatedProp<DT[P]>;
+    } : DT : never;
+};
+type AnimatedStyle<T> = [T, T] extends [infer T, infer DT] ? DT extends void ? undefined : [DT] extends [never] ? never : DT extends object ? {
+    [P in keyof DT]: AnimatedStyle<DT[P]>;
+} : DT | AnimatedLeaf<T> : never;
+type AnimatedLeaf<T> = Exclude<T, object | undefined> | Extract<T, ReadonlyArray<number | string>> extends infer U ? [U] extends [never] ? never : FluidValue<U | Exclude<T, object | undefined>> : never;
+
+declare const animated: WithAnimated;
+
+declare global {
+    /**
+     * The **`console`** object provides access to the debugging console (e.g., the Web console in Firefox).
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console)
+     */
+    interface Console {
+        /**
+         * The **`console.debug()`** static method outputs a message to the console at the 'debug' log level.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static)
+         */
+        debug(...data: any[]): void;
+        /**
+         * The **`console.error()`** static method outputs a message to the console at the 'error' log level.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static)
+         */
+        error(...data: any[]): void;
+        /**
+         * The **`console.info()`** static method outputs a message to the console at the 'info' log level.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static)
+         */
+        info(...data: any[]): void;
+        /**
+         * The **`console.log()`** static method outputs a message to the console.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static)
+         */
+        log(...data: any[]): void;
+        /**
+         * The **`console.trace()`** static method outputs a stack trace to the console.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static)
+         */
+        trace(...data: any[]): void;
+        /**
+         * The **`console.warn()`** static method outputs a warning message to the console at the 'warning' log level.
+         *
+         * [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static)
+         */
+        warn(...data: any[]): void;
+    }
+    var console: Console;
+    type TimerHandler = string | Function;
+    function clearInterval(id: number | undefined): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearTimeout) */
+    function clearTimeout(id: number | undefined): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setInterval) */
+    function setInterval(handler: TimerHandler, timeout?: number, ...args: any[]): number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout) */
+    function setTimeout(handler: TimerHandler, timeout?: number, ...args: any[]): number;
+    type DOMHighResTimeStamp = number;
+    type FrameRequestCallback = (time: DOMHighResTimeStamp) => void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/cancelAnimationFrame) */
+    function cancelAnimationFrame(handle: number): void;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DedicatedWorkerGlobalScope/requestAnimationFrame) */
+    function requestAnimationFrame(callback: FrameRequestCallback): number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */
+    function queueMicrotask(callback: () => void): void;
+}
+
+/** biome-ignore-all lint/suspicious/noExplicitAny: too tight for this file */
+
+/**
+ * Context for page parameters
+ * Used to provide params to page components via React tree
+ */
+declare const PageParamsContext: React__default.Context<Record<string, any> | undefined>;
+/**
+ * Context for overlay parameters
+ * Used to provide params to overlay components via React tree
+ */
+declare const OverlayParamsContext: React__default.Context<Record<string, any> | undefined>;
+/**
+ * Placeholder for global navigation types.
+ * Projects can augment this interface to provide type safety for the global navigator.
+ * @example
+ * declare module './utils/navigation' {
+ *   interface RootNavigatorList {
+ *     pages: typeof myPages;
+ *     overlays: typeof myOverlays;
+ *   }
+ * }
+ */
+interface RootNavigatorList {
+}
+/**
+ * Type helper to register a navigator instance's types globally.
+ * Use this in a declare module block to get automatic type safety.
+ */
+type RegisterNavigator<T extends Navigator<any, any>> = {
+    pages: T extends Navigator<infer P, any> ? Record<P, any> : never;
+    overlays: T extends Navigator<any, infer O> ? Record<O, any> : never;
+};
+type GetPages<T> = T extends {
+    pages: infer P;
+} ? (P extends Record<string, any> ? keyof P & string : string) : string;
+type GetOverlays<T> = T extends {
+    overlays: infer O;
+} ? O extends Record<string, any> ? keyof O & string : string : string;
+type DefaultPageName = GetPages<RootNavigatorList>;
+type DefaultOverlayName = GetOverlays<RootNavigatorList>;
+interface PageDescriptor {
+    component: React__default.ComponentType<any>;
+    options?: Record<string, any>;
+    requiredParams?: string[];
+}
+interface OverlayDescriptor {
+    component: React__default.ComponentType<any>;
+    options?: Record<string, any>;
+    requiredParams?: string[];
+}
+type PageConfig = PageDescriptor['component'] | PageDescriptor;
+type OverlayConfig = OverlayDescriptor['component'] | OverlayDescriptor;
+interface StackNavigatorOptions<Pages extends Record<string, PageConfig>, Overlays extends Record<string, OverlayConfig>> {
+    initialPage: keyof Pages & string;
+    pages: Pages;
+    overlays?: Overlays;
+}
+interface Navigator<PageName extends string = DefaultPageName, OverlayName extends string = DefaultOverlayName> {
+    /**
+     * Navigate to a page
+     * @param page Page name
+     * @param params Parameters to pass to the page (optional)
+     */
+    navigate: (page: PageName, params?: Record<string, any>) => void;
+    /**
+     * Go back to the previous page (not implemented yet)
+     */
+    goBack: () => void;
+    /**
+     * Push an overlay to the overlay stack
+     * @param overlay Overlay name
+     * @param params Parameters to pass to the overlay (optional)
+     */
+    pushOverlay: (overlay: OverlayName, params?: Record<string, any>) => void;
+    /**
+     * Pop the top overlay from the stack
+     */
+    popOverlay: () => void;
+    /**
+     * Clear all overlays
+     */
+    clearOverlays: () => void;
+    /**
+     * Get current page name
+     */
+    getCurrentPage: () => PageName;
+    /**
+     * Get current page parameters
+     */
+    getParams: () => Record<string, any> | undefined;
+    /**
+     * Get overlay stack
+     */
+    getOverlayStack: () => OverlayInfo[];
+    /**
+     * Check if an overlay is active
+     * @param type Overlay type/name
+     */
+    isOverlayActive: (type: OverlayName) => boolean;
+    /** @internal */
+    _descriptors: {
+        pages: Record<string, PageDescriptor>;
+        overlays: Record<string, OverlayDescriptor>;
+    };
+    /** @internal */
+    _state: NavigationState;
+}
+interface OverlayInfo {
+    type: string;
+    id: string;
+}
+interface NavigationState {
+    currentPage: string;
+    pageParams: Record<string, Record<string, any>>;
+    overlayStack: OverlayInfo[];
+    overlayParams: Record<string, Record<string, any>>;
+}
+/**
+ * Create a stack navigator
+ * @param options Navigator configuration
+ * @returns Navigator instance
+ */
+declare function createStackNavigator<Pages extends Record<string, PageConfig>, Overlays extends Record<string, OverlayConfig>>(options: StackNavigatorOptions<Pages, Overlays>): Navigator<keyof Pages & string, keyof Overlays & string>;
+/**
+ * Create a navigation component for a navigator
+ * @param navigator The navigator instance
+ * @returns A React component that renders the navigation state
+ */
+declare function createStaticNavigation(navigator: Navigator<any, any>): React__default.FC;
+/**
+ * Get the navigator instance (stable reference)
+ * Can be used in both components and state logic
+ * @returns Navigator object
+ */
+declare function getNavigator<PageName extends string = DefaultPageName, OverlayName extends string = DefaultOverlayName>(): Navigator<PageName, OverlayName>;
+/**
+ * Hook to get the navigator instance in components
+ */
+declare const useNavigation: typeof getNavigator;
+/**
+ * Reactively read the global navigation state.
+ * This keeps the Valtio proxy encapsulated inside kit so consumers don't need
+ * to touch the internal `_state` field directly.
+ */
+declare function useNavigationState(): Snapshot<NavigationState>;
+/**
+ * Get navigation parameters for current component
+ * @returns Parameters object (cast as T)
+ *
+ * This hook reads params from React Context, which is provided by the router.
+ * - If called from within an overlay context, returns overlay params
+ * - If called from within a page context, returns page params
+ * - Supports multiple nested overlays (each gets its own params)
+ *
+ * Note: We cast the result to T and provide an empty object as fallback.
+ * Since required parameters are validated at navigation entry points, we can
+ * safely assume the runtime object matches T.
+ */
+declare function useNavigationParams<T = Record<string, any>>(): T;
+
+declare function useFadeInOut(inTime: number, _keepTime: number, _outTime: number, pause?: boolean, onFinished?: () => void): [SpringValues<{
+    opacity: number;
+}>, SpringRef<{
+    opacity: number;
+}>, () => void];
+declare function useFadeIn(inTime: number, pause?: boolean, onFinished?: () => void): [SpringValues<{
+    opacity: number;
+}>, SpringRef<{
+    opacity: number;
+}>, () => void];
+declare function useFadeOut(outTime: number, pause?: boolean, onFinished?: () => void): [SpringValues<{
+    opacity: number;
+}>, SpringRef<{
+    opacity: number;
+}>, () => void];
+
+/** Advance to the next line in the current story. */
+declare function nextLine(): any;
+/** Set a timed wait, optionally skippable. */
+declare function setWaiting(time: number, skippable: boolean): void;
+/**
+ * Custom hook to manage scenario lifecycle (load, start, terminate).
+ *
+ * @param {string[]} stories - An array of story names to load.
+ * @param {string} [startName] - The name of the story to start.
+ * @param {string} [entryName] - The entry point within the story to start from.
+ * @param {boolean} [goNextOnLoad=false] - Whether to automatically advance to the next line after loading.
+ */
+declare function useScenario(stories: string[], startName?: string, entryName?: string, goNextOnLoad?: boolean): void;
+
+/**
+ * Used to load a sound effect and provide a function to play it.
+ */
+declare function useSoundEffect(src: string): () => void;
+
+/** Flow control interface passed to every handler. */
+interface GameControl {
+    /** Timed wait — blocks auto-advance. Engine fires scenariowaitingcancelled on timeout or skip. */
+    setWaiting(time: number, skippable: boolean): void;
+    /** Indefinite hold — blocks auto-advance until user action. */
+    hold(): void;
+    /** Manually advance (rarely needed, e.g. `!` tailing). */
+    nextLine(): void;
+    /** Mark this dispatch cycle as unskippable. If skipping, hold() will stop skip instead of advancing. */
+    unskippable(): void;
+    /** Record the current runtime snapshot for backlog usage. */
+    record(meta: Record<string, any>): string;
+}
+interface ScenarioCommandBaseType {
+    command: string;
+    [key: string]: unknown;
+}
+/** Command handler function. */
+type CommandHandler<T extends ScenarioCommandBaseType = ScenarioCommandBaseType> = (cmd: T, control: GameControl) => void;
+/** Text line handler function. */
+type TextLineHandler = (text: TextLine, control: GameControl) => void;
+interface AutoTicketOptions {
+    label?: string;
+    tailMs?: number;
+}
+interface AutoTicketHandle {
+    done(): void;
+    cancel(): void;
+}
+/** Reactive skip state. Actors read via useIsSkipping(). */
+declare const skipState: {
+    active: boolean;
+};
+/** Reactive auto state. Actors read via useIsAutoing(). */
+declare const autoState: {
+    active: boolean;
+};
+/** Reactively returns whether skip (Ctrl fast-forward) is active. */
+declare function useIsSkipping(): boolean;
+/** Reactively returns whether auto mode is active. */
+declare function useIsAutoing(): boolean;
+/** Set the default tail delay in milliseconds for newly created auto tickets. */
+declare function setDefaultAutoTailMs(ms: number): void;
+declare function createStage(): {
+    registerCommandSchema: <T extends ZodType>(schema: T) => () => void;
+    registerCommand: <T extends ScenarioCommandBaseType>(commands: string | string[], handler: CommandHandler<T>) => () => void;
+    registerTextLine: (handler: TextLineHandler) => () => void;
+    addSkipCallback: (cb: () => void) => () => void;
+    addInterruptCallback: (cb: () => boolean) => () => void;
+    addSkipBlocker: (cb: () => boolean) => () => void;
+    addAutoBlocker: (cb: () => boolean) => () => void;
+    addBeforeHandleCommandCallback: (cb: (upcomingCommand: ResolvedCommandLine) => void) => () => void;
+    issueAutoTicket: (options?: AutoTicketOptions) => AutoTicketHandle | null;
+    tryInterrupt: () => boolean;
+    startSkip: () => void;
+    stopSkip: () => void;
+    isSkipping: () => boolean;
+    startAuto: () => void;
+    stopAuto: () => void;
+    isAutoing: () => boolean;
+    bindEvents: () => () => void;
+};
+type StageInstance = ReturnType<typeof createStage>;
+/** Access the stage instance from within StageContextProvider. */
+declare function useStageContext(): StageInstance;
+declare function StageContextProvider({ stage, children }: {
+    stage: StageInstance;
+    children: React.ReactNode;
+}): React$1.FunctionComponentElement<React$1.ProviderProps<{
+    registerCommandSchema: <T extends ZodType>(schema: T) => () => void;
+    registerCommand: <T extends ScenarioCommandBaseType>(commands: string | string[], handler: CommandHandler<T>) => () => void;
+    registerTextLine: (handler: TextLineHandler) => () => void;
+    addSkipCallback: (cb: () => void) => () => void;
+    addInterruptCallback: (cb: () => boolean) => () => void;
+    addSkipBlocker: (cb: () => boolean) => () => void;
+    addAutoBlocker: (cb: () => boolean) => () => void;
+    addBeforeHandleCommandCallback: (cb: (upcomingCommand: ResolvedCommandLine) => void) => () => void;
+    issueAutoTicket: (options?: AutoTicketOptions) => AutoTicketHandle | null;
+    tryInterrupt: () => boolean;
+    startSkip: () => void;
+    stopSkip: () => void;
+    isSkipping: () => boolean;
+    startAuto: () => void;
+    stopAuto: () => void;
+    isAutoing: () => boolean;
+    bindEvents: () => () => void;
+} | null>>;
+/**
+ * Register a skip callback that fires when scenariowaitingcancelled is received.
+ * Automatically removed on unmount.
+ */
+declare function useSkipCallback(callback: () => void): void;
+/**
+ * Register an interrupt callback for user click handling.
+ * Return `true` from the callback to consume the click.
+ * Automatically removed on unmount.
+ */
+declare function useInterruptCallback(callback: () => boolean): void;
+/**
+ * Register a skip blocker callback. Return `true` to block skipping.
+ * When any blocker is active, skip mode cannot start or will be stopped.
+ * Automatically removed on unmount.
+ *
+ * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
+ */
+declare function useSkipBlocker(callback: () => boolean): void;
+/**
+ * Register an auto blocker callback. Return `true` to block auto mode.
+ * Automatically removed on unmount.
+ *
+ * NOTE: `callback` must be a stable reference (wrap with `useCallback`).
+ */
+declare function useAutoBlocker(callback: () => boolean): void;
+/**
+ * Get a function that issues an auto ticket for the current active barrier.
+ * Returns `null` when auto is inactive or the collection window has closed.
+ */
+declare function useAutoTicket(): (options?: AutoTicketOptions) => AutoTicketHandle | null;
+/**
+ * Register a callback to be invoked before handling each command.
+ * The callback receives the upcoming command object, allowing conditional logic.
+ * Automatically removed on unmount.
+ */
+declare function useBeforeHandleCommandCallback(callback: (upcomingCommand: ResolvedCommandLine) => void): void;
+
+declare module 'zod' {
+    interface GlobalMeta {
+        title?: string;
+        format?: string;
+        'x-asset-kind'?: 'audio' | 'image' | 'font' | 'video' | 'other';
+        'x-i18n'?: Record<string, string>;
+        'x-i18n-desc'?: Record<string, string>;
+    }
+}
+
+export { type AnimatedComponent, type AnimatedProps, type AnimationFrameCallbackEvent, type AutoTicketHandle, type AutoTicketOptions, type BeforeUnloadEvent, Command, type CommandHandler, type CustomEvent, type DefaultOverlayName, type DefaultPageName, type FocusEvent, type FocusEventKind, type FullScreenEvent, type FullscreenEventKind, type GameControl, type GameEvent, type Gamepad, type GamepadButton, type GamepadEvent, type GamepadHapticActuator, JSX, type KeyboardLocation, type Literal, MaybePromise, MouseEvent, MoyuEvent, MoyuRenderer, type NavigationState, type Navigator, Node, type NodeEvent, type OverlayConfig, type OverlayDescriptor, type OverlayInfo, OverlayParamsContext, type PageConfig, type PageDescriptor, PageParamsContext, type RegisterNavigator, type ResizeEvent, type ResolvedArgument, type ResolvedCommandLine, type ResolvedSystemCallLine, type RootNavigatorList, type RootOptions, type ScenarioCommandBaseType, type ScenarioEvent, type StackNavigatorOptions, StageContextProvider, type StageInstance, type TextEvent, type TextLine, type TextLineHandler, type WheelEvent, type WheelEventDeltaMode, type WithAnimated, animated as a, addEventListener, animated, autoState, createRoot, createStackNavigator, createStage, createStaticNavigation, executeNodeCommand, executePluginCommand, getNavigator, globalEventListeners, globalRequestAnimationFrameListeners, moyu, nextLine, setDefaultAutoTailMs, setWaiting, skipState, useAutoBlocker, useAutoTicket, useBeforeHandleCommandCallback, useFadeIn, useFadeInOut, useFadeOut, useInterruptCallback, useIsAutoing, useIsSkipping, useNavigation, useNavigationParams, useNavigationState, useScenario, useSkipBlocker, useSkipCallback, useSoundEffect, useStageContext };