@omnipad/core 0.2.0-alpha.3 → 0.4.0

package/dist/index.d.cts

@@ -0,0 +1,1118 @@
+import { I as ICoreEntity, V as Vec2, G as GamepadMappingConfig, a as ISpatial, b as IResettable, c as IConfigurable, d as IObservable, E as EntityType, A as AbstractRect, B as ButtonConfig, e as IPointerHandler, f as IProgrammatic, g as AbstractPointerEvent, D as DPadConfig, h as InputZoneConfig, i as IDependencyBindable, j as AnyFunction, J as JoystickConfig, k as BaseConfig, T as TargetZoneConfig, l as ISignalReceiver, m as InputActionSignal, n as TrackpadConfig } from './index-DRA1rw5_.cjs';
+export { o as ACTION_TYPES, p as ActionMapping, q as AnchorPoint, r as AnyConfig, s as AnyEntityType, t as BuiltInActionType, C as CMP_TYPES, u as CONTEXT, v as ConfigTreeNode, F as FlatConfigItem, w as FlexibleLength, x as GamepadProfile, y as IIdentifiable, z as ILifecycle, H as InputActionType, K as KEYS, L as KeyMapping, M as LayoutBox, S as StageId, N as StandardButton, U as Unit, W as WidgetId, O as WidgetType, Z as ZoneId, P as ZoneType } from './index-DRA1rw5_.cjs';
+
+/**
+ * Interface for the global Registry singleton.
+ */
+interface IRegistry {
+    /**
+     * Registers an entity into the system.
+     * Usually called during a component's constructor or onMounted lifecycle.
+     *
+     * @param entity - The logic entity instance to register.
+     */
+    register(entity: ICoreEntity): void;
+    /**
+     * Unregisters an entity from the system.
+     * Usually called during a component's destroy or onUnmounted lifecycle.
+     *
+     * @param uid - The unique identifier of the entity.
+     */
+    unregister(uid: string): void;
+    /**
+     * Queries an entity by its UID.
+     * Supports generics for easy type casting to specific logic types (e.g., ISignalReceiver).
+     *
+     * @example
+     * // usually global ID like "$main-stage"
+     * const stage = Registry.getInstance().getEntity<TargetZoneCore>('$main-stage');
+     *
+     * @param uid - The unique identifier of the target entity.
+     * @returns The entity instance, or undefined if not found.
+     */
+    getEntity<T extends ICoreEntity = ICoreEntity>(uid: string): T | undefined;
+    /**
+     * Returns a flat array of all currently registered entities.
+     * Useful for global operations or full-profile backups.
+     */
+    getAllEntities(): ICoreEntity[];
+    /**
+     * Retrieves an entity and all its recursive descendants based on parentId relationships.
+     *
+     * @param rootUid - The UID of the entity to start the search from.
+     * @returns An array of entities belonging to the specified subtree (including the root).
+     */
+    getEntitiesByRoot(rootUid: string): ICoreEntity[];
+    /**
+     * Recursively destroys an entity and all its descendants.
+     * Ensures all signals are cut off and instances are removed from the registry.
+     *
+     * @param rootUid - The Entity ID of the root node to be destroyed.
+     */
+    destroyByRoot(rootUid: string): void;
+    /**
+     * Triggers the reset() method on all compatible entities.
+     * Essential for cutting off active input signals (e.g., stuck keys) during profile reloads.
+     */
+    resetAll(): void;
+    /**
+     * Clears all registered entities.
+     * Used for system resets or full application unmounts.
+     */
+    clear(): void;
+}
+
+/**
+ * Metadata for basic pointer interaction.
+ * Shared by all interactable entities to track physical touch/mouse state.
+ */
+interface InteractionState {
+    /** Indicates if the component is currently being touched or clicked. */
+    isActive: boolean;
+    /** The unique ID of the pointer being tracked, used for Pointer Capture. */
+    pointerId: number | null;
+}
+/**
+ * Logic-level state for button-type widgets.
+ * Handles the processed output after debouncing or toggle logic.
+ */
+interface ButtonLogicState {
+    /** The final logical state of the button (true = pressed). */
+    isPressed: boolean;
+    /** Numerical value representing pressure or analog depth, ranging from 0.0 to 1.0. */
+    value: number;
+}
+/**
+ * Logic-level state for axis-type or joystick widgets.
+ * Represents the normalized directional input.
+ */
+interface AxisLogicState {
+    /** Normalized direction vector where x and y range from -1.0 to 1.0. */
+    vector: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Runtime state for the Virtual Cursor within a TargetZone.
+ */
+interface CursorState {
+    /** Current position of the cursor as a percentage (0-100) relative to the stage. */
+    position: Vec2;
+    /** Visibility toggle based on movement or configuration. */
+    isVisible: boolean;
+    /** Indicates if a logical "Mouse Down" is currently active. */
+    isPointerDown: boolean;
+    /** A temporary flag used to trigger focus-reclaim visual feedback. */
+    isFocusReturning: boolean;
+}
+/**
+ * State for managing dynamic/floating widgets within an InputZone.
+ */
+interface InputZoneState {
+    /** Indicates if a dynamic widget (e.g., a floating stick) is currently spawned. */
+    isDynamicActive: boolean;
+    /** The ID (UID) of the pointer that triggered the dynamic widget. */
+    dynamicPointerId: number | null;
+    /** The initial spawn coordinates of the dynamic widget (percentage 0-100). */
+    dynamicPosition: Vec2;
+}
+/**
+ * Basic state for Managed Layers.
+ */
+interface LayerState {
+    /** Visual hint for layout debugging or active selection. */
+    isHighlighted: boolean;
+}
+/**
+ * Combined state for Button components.
+ */
+interface ButtonState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Keyboard Button components.
+ */
+interface KeyboardButtonState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Mouse Button components.
+ */
+interface MouseButtonState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Trackpad components.
+ */
+interface TrackpadState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for D-pad components.
+ */
+interface DPadState extends InteractionState, AxisLogicState {
+}
+/**
+ * Combined state for Joystick components.
+ */
+interface JoystickState extends InteractionState, AxisLogicState, ButtonLogicState {
+}
+
+/**
+ * GamepadManager
+ *
+ * A singleton service that polls the browser Gamepad API via requestAnimationFrame.
+ * It translates physical hardware inputs into programmatic signals sent to
+ * virtual entities registered in the system.
+ *
+ * Handles:
+ * 1. Button edge detection (Down/Up).
+ * 2. D-Pad to vector conversion.
+ * 3. Analog stick deadzone processing.
+ */
+declare class GamepadManager {
+    private isRunning;
+    private config;
+    private lastButtonStates;
+    private constructor();
+    /**
+     * Retrieves the global singleton instance of the GamepadManager.
+     */
+    static getInstance(): GamepadManager;
+    /**
+     * Updates the current gamepad mapping configuration.
+     *
+     * @param config - The mapping of physical inputs to virtual component IDs (UID).
+     */
+    setConfig(config: GamepadMappingConfig[]): void;
+    /** Return the current gamepad mapping configuration. */
+    getConfig(): Readonly<GamepadMappingConfig[] | null>;
+    /**
+     * Starts the polling loop and listens for gamepad connection events.
+     */
+    start(): void;
+    /**
+     * Stops the polling loop.
+     */
+    stop(): void;
+    /**
+     * The core polling loop executing at the browser's refresh rate.
+     */
+    private loop;
+    /**
+     * Process binary button inputs with edge detection.
+     */
+    private processButtons;
+    /**
+     * Translates physical D-Pad buttons into a normalized vector.
+     */
+    private processDPad;
+    /**
+     * Process analog stick movements with deadzone logic.
+     */
+    private processAxes;
+    /**
+     * Locates a virtual entity and triggers its programmatic interface.
+     *
+     * @param uid - The Entity ID (UID) of the target.
+     * @param action - The type of trigger ('down', 'up', or 'vector').
+     * @param payload - Optional data for vector movements.
+     */
+    private triggerVirtualEntity;
+}
+
+/**
+ * Global Input Manager Singleton.
+ *
+ * Responsible for monitoring global browser events (resize, blur, visibility)
+ * and coordinating system-wide resets to prevent stuck inputs.
+ */
+declare class InputManager {
+    /** Internal flag to prevent multiple event registrations */
+    private _isListening;
+    /** A throttled version of the reset logic */
+    private throttledReset;
+    private constructor();
+    /**
+     * Retrieves the global instance of the InputManager.
+     * Ensures uniqueness across multiple bundles or modules.
+     */
+    static getInstance(): InputManager;
+    /**
+     * Manually triggers a system-wide input reset via Registry.
+     */
+    private handleGlobalReset;
+    private handleResizeReset;
+    private handleBlurReset;
+    private handleVisibilityChangeReset;
+    /**
+     * Initializes global safety listeners.
+     * Should be called once at the root component lifecycle (e.g., VirtualLayer).
+     */
+    init(): void;
+    /**
+     * Toggle full-screen state of the page.
+     * @param element Target HTMLElement
+     */
+    toggleFullscreen(element?: HTMLElement): Promise<void>;
+    /**
+     * Full-screen status query provided to the UI layer.
+     */
+    isFullscreen(): boolean;
+    /**
+     * Detaches all global listeners.
+     */
+    destroy(): void;
+}
+
+/**
+ * Global Registry Singleton.
+ *
+ * Acts as the "Census Bureau" for the system, maintaining references to all active
+ * logic entities (Stages, Widgets, Layers). It enables cross-component communication
+ * and coordinate mapping by allowing entities to look each other up via UIDs.
+ */
+declare class Registry implements IRegistry {
+    /** Internal storage: Mapping of Entity UID to Entity Instance */
+    private entities;
+    /**
+     * Private constructor to enforce singleton pattern.
+     */
+    private constructor();
+    /**
+     * Retrieves the global instance of the Registry.
+     * Uses globalThis to ensure the instance is unique even if the library is loaded multiple times.
+     */
+    static getInstance(): Registry;
+    register(entity: ICoreEntity): void;
+    unregister(uid: string): void;
+    getEntity<T extends ICoreEntity = ICoreEntity>(uid: string): T | undefined;
+    getAllEntities(): ICoreEntity[];
+    getEntitiesByRoot(rootUid: string): ICoreEntity[];
+    destroyByRoot(rootUid: string): void;
+    clear(): void;
+    resetAll(): void;
+    debugGetSnapshot(): Map<string, ICoreEntity>;
+}
+
+/**
+ * Represents a callback function for the emitter.
+ * @template T - The type of data being broadcasted.
+ */
+type Listener<T> = (data: T) => void;
+/**
+ * A lightweight implementation of the Observer pattern.
+ * Used primarily within Core Entities to notify the Adapter layer of state changes.
+ *
+ * @template T - The state or data object type.
+ */
+declare class SimpleEmitter<T> {
+    private listeners;
+    /**
+     * Registers a callback function to be executed whenever data is emitted.
+     *
+     * @param fn - The callback function.
+     * @returns A function that, when called, unsubscribes the listener.
+     */
+    subscribe(fn: Listener<T>): () => void;
+    /**
+     * Broadcasts the provided data to all registered listeners.
+     * Each listener is executed within a try-catch block to ensure that
+     * an error in one subscriber doesn't prevent others from receiving the signal.
+     *
+     * @param data - The payload to be sent to all subscribers.
+     */
+    emit(data: T): void;
+    /**
+     * Removes all listeners and clears the subscription set.
+     * Essential for preventing memory leaks when an Entity is destroyed.
+     */
+    clear(): void;
+}
+
+/**
+ * Base abstract class for all logic entities in the system.
+ * Provides fundamental identity management, state subscription, and spatial awareness.
+ */
+declare abstract class BaseEntity<TConfig, TState> implements ICoreEntity, ISpatial, IResettable, IConfigurable<TConfig>, IObservable<TState> {
+    readonly uid: string;
+    readonly type: EntityType;
+    protected config: TConfig;
+    protected state: TState;
+    protected rectProvider: (() => AbstractRect) | null;
+    protected stateEmitter: SimpleEmitter<TState>;
+    constructor(uid: string, type: EntityType, initialConfig: TConfig, initialState: TState);
+    subscribe(cb: (state: TState) => void): () => void;
+    /**
+     * Updates the internal state and notifies all subscribers.
+     *
+     * @param partialState - Partial object containing updated state values.
+     */
+    protected setState(partialState: Partial<TState>): void;
+    destroy(): void;
+    abstract reset(): void;
+    get rect(): AbstractRect | null;
+    bindRectProvider(provider: () => AbstractRect): void;
+    updateConfig(newConfig: Partial<TConfig>): void;
+    getState(): Readonly<TState>;
+    getConfig(): Readonly<TConfig>;
+}
+
+/**
+ * Core logic implementation for a button widget.
+ * Handles pointer interactions and translates them into keyboard signals for a target stage.
+ */
+declare class ButtonCore extends BaseEntity<ButtonConfig, ButtonState> implements IPointerHandler, IProgrammatic {
+    private emitter;
+    /**
+     * Creates an instance of KeyboardButtonCore.
+     *
+     * @param uid - The unique entity ID.
+     * @param config - The flat configuration object for the button.
+     */
+    constructor(uid: string, config: ButtonConfig);
+    get activePointerId(): number | null;
+    onPointerDown(e: AbstractPointerEvent): void;
+    onPointerUp(e: AbstractPointerEvent): void;
+    onPointerCancel(): void;
+    onPointerMove(): void;
+    reset(): void;
+    updateConfig(newConfig: Partial<ButtonConfig>): void;
+    /**
+     * Clean up pointer capture and reset interaction state.
+     */
+    private handleRelease;
+    triggerDown(): void;
+    triggerUp(): void;
+}
+
+/**
+ * Core logic for a virtual D-Pad widget.
+ *
+ * Acts as a spatial distributor that maps a single touch point to 4 independent ActionEmitters.
+ * Supports 8-way input by allowing simultaneous activation of orthogonal directions.
+ */
+declare class DPadCore extends BaseEntity<DPadConfig, DPadState> implements IPointerHandler, IProgrammatic {
+    private emitters;
+    private throttledPointerMove;
+    constructor(uid: string, config: DPadConfig);
+    get activePointerId(): number | null;
+    onPointerDown(e: AbstractPointerEvent): void;
+    onPointerMove(e: AbstractPointerEvent): void;
+    onPointerUp(e: AbstractPointerEvent): void;
+    onPointerCancel(): void;
+    /**
+     * Evaluates the touch position and updates the 4 emitters accordingly.
+     * 使用轴向分割逻辑处理 8 方向输入
+     */
+    private processInput;
+    /**
+     * 将摇杆位置转换为 4/8 方向按键信号
+     */
+    private handleDigitalKeys;
+    reset(): void;
+    updateConfig(newConfig: Partial<DPadConfig>): void;
+    triggerVector(x: number, y: number): void;
+}
+
+/**
+ * Logic core for InputZone.
+ *
+ * Manages a container for input widgets and handles the lifecycle of
+ * dynamic (floating) widgets when interacting with empty space.
+ */
+declare class InputZoneCore extends BaseEntity<InputZoneConfig, InputZoneState> implements IPointerHandler, IDependencyBindable {
+    private delegates;
+    constructor(uid: string, config: InputZoneConfig);
+    bindDelegate(key: string, delegate: AnyFunction): void;
+    get activePointerId(): number | null;
+    onPointerDown(e: AbstractPointerEvent): void;
+    onPointerMove(e: AbstractPointerEvent): void;
+    onPointerUp(e: AbstractPointerEvent): void;
+    onPointerCancel(e: AbstractPointerEvent): void;
+    /**
+     * Converts viewport pixels to percentage coordinates relative to the zone.
+     */
+    private calculateRelativePosition;
+    /**
+     * Whether the interceptor layer should be enabled.
+     */
+    get isInterceptorRequired(): boolean;
+    reset(): void;
+}
+
+/**
+ * Joystick Core Implementation.
+ *
+ * Supports dual-mode output:
+ * 1. Digital: Maps angles to 4/8-way key signals.
+ * 2. Analog/Cursor: Maps vector to continuous cursor movement via Tick mechanism.
+ */
+declare class JoystickCore extends BaseEntity<JoystickConfig, JoystickState> implements IPointerHandler, IProgrammatic {
+    private emitters;
+    private stickEmitter;
+    private cursorEmitter;
+    private gesture;
+    private ticker;
+    private throttledUpdate;
+    constructor(uid: string, config: JoystickConfig);
+    get activePointerId(): number | null;
+    onPointerDown(e: AbstractPointerEvent): void;
+    onPointerMove(e: AbstractPointerEvent): void;
+    onPointerUp(e: AbstractPointerEvent): void;
+    onPointerCancel(): void;
+    /**
+     * Clean up pointer capture and reset interaction state.
+     */
+    private handleRelease;
+    /**
+     * 计算位移向量并驱动按键逻辑 / Calculate vector and drive key logic
+     */
+    private processInput;
+    /**
+     * Ticker 回调：处理每帧的光标位移输出
+     */
+    private handleCursorTick;
+    /**
+     * 将摇杆位置转换为 4/8 方向按键信号
+     */
+    private handleDigitalKeys;
+    reset(): void;
+    updateConfig(newConfig: Partial<JoystickConfig>): void;
+    triggerDown(): void;
+    triggerUp(): void;
+    triggerVector(x: number, y: number): void;
+}
+
+/**
+ * Core logic for the Root/Managed Layer.
+ *
+ * Acts as the top-level container for a gamepad profile, providing the base
+ * identity (UID) and coordinate reference for all descendant components.
+ */
+declare class RootLayerCore extends BaseEntity<BaseConfig, LayerState> {
+    constructor(uid: string, config: BaseConfig);
+    reset(): void;
+}
+
+/**
+ * Core logic for the Target Focus Zone.
+ *
+ * It acts as a receiver that translates abstract input signals into native browser events,
+ * while maintaining virtual cursor positioning and ensuring the game maintains focus.
+ */
+declare class TargetZoneCore extends BaseEntity<TargetZoneConfig, CursorState> implements IPointerHandler, ISignalReceiver, IDependencyBindable {
+    private hideTimer;
+    private focusFeedbackTimer;
+    private throttledPointerMove;
+    private delegates;
+    constructor(uid: string, config: TargetZoneConfig);
+    bindDelegate(key: string, delegate: AnyFunction): void;
+    get activePointerId(): number | null;
+    onPointerDown(e: AbstractPointerEvent): void;
+    onPointerMove(e: AbstractPointerEvent): void;
+    onPointerUp(e: AbstractPointerEvent): void;
+    onPointerCancel(e: AbstractPointerEvent): void;
+    /**
+     * Convert physical DOM events into internal signals
+     */
+    private processPhysicalEvent;
+    handleSignal(signal: InputActionSignal): void;
+    /**
+     * Calculates pixel coordinates and dispatches simulated pointer events to the deepest element.
+     *
+     * @param pointerType - The specific pointer event type (e.g., pointermove, pointerdown).
+     * @param payload - Data containing point coordinates or button info.
+     */
+    private executeMouseAction;
+    /**
+     * Checks if the target element under the virtual cursor has focus, and reclaims it if lost.
+     */
+    private ensureFocus;
+    /**
+     * Activates a temporary visual feedback state to indicate a focus-reclaim event.
+     */
+    private triggerFocusFeedback;
+    /**
+     * Updates the internal virtual cursor coordinates.
+     */
+    private updateCursorPosition;
+    /**
+     * Updates the internal virtual cursor coordinates by delta.
+     */
+    private updateCursorPositionByDelta;
+    /**
+     * Makes the virtual cursor visible and sets a timeout for auto-hiding.
+     */
+    private showCursor;
+    reset(): void;
+}
+
+/**
+ * Core logic implementation for a trackpad widget.
+ *
+ * Translates pointer gestures into relative mouse movements and click actions.
+ * Supports:
+ * - Single Tap: Dispatches a 'click' signal.
+ * - Swipe: Dispatches incremental 'mousemove' signals.
+ * - Double-tap and Hold: Enters drag mode (mousedown + mousemove).
+ */
+declare class TrackpadCore extends BaseEntity<TrackpadConfig, TrackpadState> implements IPointerHandler {
+    /** Stores the last processed client coordinates to calculate delta / 存储上次处理的客户端坐标以计算增量 */
+    private lastPointerPos;
+    private throttledPointerMove;
+    private gesture;
+    private emitter;
+    /**
+     * Creates an instance of TrackpadCore.
+     *
+     * @param uid - Unique entity ID.
+     * @param config - Configuration for the trackpad.
+     */
+    constructor(uid: string, config: TrackpadConfig);
+    get activePointerId(): number | null;
+    onPointerDown(e: AbstractPointerEvent): void;
+    onPointerMove(e: AbstractPointerEvent): void;
+    /**
+     * Internal logic for processing pointer movement.
+     * Calculates displacement and emits relative move signals.
+     *
+     * @param e - The pointer event.
+     */
+    private processPointerMove;
+    onPointerUp(e: AbstractPointerEvent): void;
+    onPointerCancel(): void;
+    reset(): void;
+    updateConfig(newConfig: Partial<TrackpadConfig>): void;
+    /**
+     * Clean up pointer capture and reset interaction state.
+     */
+    private handleRelease;
+}
+
+declare const OmniPad: {
+    ActionTypes: {
+        readonly KEYDOWN: "keydown";
+        readonly KEYUP: "keyup";
+        readonly POINTER: "pointer";
+        readonly POINTERMOVE: "pointermove";
+        readonly POINTERDOWN: "pointerdown";
+        readonly POINTERUP: "pointerup";
+        readonly MOUSE: "mouse";
+        readonly MOUSEMOVE: "mousemove";
+        readonly MOUSEDOWN: "mousedown";
+        readonly MOUSEUP: "mouseup";
+        readonly CLICK: "click";
+    };
+    Context: {
+        readonly PARENT_ID_KEY: "omnipad-parent-id-link";
+    };
+    Keys: {
+        readonly Backspace: {
+            readonly key: "Backspace";
+            readonly code: "Backspace";
+            readonly keyCode: 8;
+        };
+        readonly Tab: {
+            readonly key: "Tab";
+            readonly code: "Tab";
+            readonly keyCode: 9;
+        };
+        readonly Enter: {
+            readonly key: "Enter";
+            readonly code: "Enter";
+            readonly keyCode: 13;
+        };
+        readonly ShiftLeft: {
+            readonly key: "Shift";
+            readonly code: "ShiftLeft";
+            readonly keyCode: 16;
+        };
+        readonly ControlLeft: {
+            readonly key: "Control";
+            readonly code: "ControlLeft";
+            readonly keyCode: 17;
+        };
+        readonly AltLeft: {
+            readonly key: "Alt";
+            readonly code: "AltLeft";
+            readonly keyCode: 18;
+        };
+        readonly Pause: {
+            readonly key: "Pause";
+            readonly code: "Pause";
+            readonly keyCode: 19;
+        };
+        readonly CapsLock: {
+            readonly key: "CapsLock";
+            readonly code: "CapsLock";
+            readonly keyCode: 20;
+        };
+        readonly Escape: {
+            readonly key: "Escape";
+            readonly code: "Escape";
+            readonly keyCode: 27;
+        };
+        readonly Space: {
+            readonly key: " ";
+            readonly code: "Space";
+            readonly keyCode: 32;
+        };
+        readonly PageUp: {
+            readonly key: "PageUp";
+            readonly code: "PageUp";
+            readonly keyCode: 33;
+        };
+        readonly PageDown: {
+            readonly key: "PageDown";
+            readonly code: "PageDown";
+            readonly keyCode: 34;
+        };
+        readonly End: {
+            readonly key: "End";
+            readonly code: "End";
+            readonly keyCode: 35;
+        };
+        readonly Home: {
+            readonly key: "Home";
+            readonly code: "Home";
+            readonly keyCode: 36;
+        };
+        readonly ArrowLeft: {
+            readonly key: "ArrowLeft";
+            readonly code: "ArrowLeft";
+            readonly keyCode: 37;
+        };
+        readonly ArrowUp: {
+            readonly key: "ArrowUp";
+            readonly code: "ArrowUp";
+            readonly keyCode: 38;
+        };
+        readonly ArrowRight: {
+            readonly key: "ArrowRight";
+            readonly code: "ArrowRight";
+            readonly keyCode: 39;
+        };
+        readonly ArrowDown: {
+            readonly key: "ArrowDown";
+            readonly code: "ArrowDown";
+            readonly keyCode: 40;
+        };
+        readonly PrintScreen: {
+            readonly key: "PrintScreen";
+            readonly code: "PrintScreen";
+            readonly keyCode: 44;
+        };
+        readonly Insert: {
+            readonly key: "Insert";
+            readonly code: "Insert";
+            readonly keyCode: 45;
+        };
+        readonly Delete: {
+            readonly key: "Delete";
+            readonly code: "Delete";
+            readonly keyCode: 46;
+        };
+        readonly Digit0: {
+            readonly key: "0";
+            readonly code: "Digit0";
+            readonly keyCode: 48;
+        };
+        readonly Digit1: {
+            readonly key: "1";
+            readonly code: "Digit1";
+            readonly keyCode: 49;
+        };
+        readonly Digit2: {
+            readonly key: "2";
+            readonly code: "Digit2";
+            readonly keyCode: 50;
+        };
+        readonly Digit3: {
+            readonly key: "3";
+            readonly code: "Digit3";
+            readonly keyCode: 51;
+        };
+        readonly Digit4: {
+            readonly key: "4";
+            readonly code: "Digit4";
+            readonly keyCode: 52;
+        };
+        readonly Digit5: {
+            readonly key: "5";
+            readonly code: "Digit5";
+            readonly keyCode: 53;
+        };
+        readonly Digit6: {
+            readonly key: "6";
+            readonly code: "Digit6";
+            readonly keyCode: 54;
+        };
+        readonly Digit7: {
+            readonly key: "7";
+            readonly code: "Digit7";
+            readonly keyCode: 55;
+        };
+        readonly Digit8: {
+            readonly key: "8";
+            readonly code: "Digit8";
+            readonly keyCode: 56;
+        };
+        readonly Digit9: {
+            readonly key: "9";
+            readonly code: "Digit9";
+            readonly keyCode: 57;
+        };
+        readonly KeyA: {
+            readonly key: "a";
+            readonly code: "KeyA";
+            readonly keyCode: 65;
+        };
+        readonly KeyB: {
+            readonly key: "b";
+            readonly code: "KeyB";
+            readonly keyCode: 66;
+        };
+        readonly KeyC: {
+            readonly key: "c";
+            readonly code: "KeyC";
+            readonly keyCode: 67;
+        };
+        readonly KeyD: {
+            readonly key: "d";
+            readonly code: "KeyD";
+            readonly keyCode: 68;
+        };
+        readonly KeyE: {
+            readonly key: "e";
+            readonly code: "KeyE";
+            readonly keyCode: 69;
+        };
+        readonly KeyF: {
+            readonly key: "f";
+            readonly code: "KeyF";
+            readonly keyCode: 70;
+        };
+        readonly KeyG: {
+            readonly key: "g";
+            readonly code: "KeyG";
+            readonly keyCode: 71;
+        };
+        readonly KeyH: {
+            readonly key: "h";
+            readonly code: "KeyH";
+            readonly keyCode: 72;
+        };
+        readonly KeyI: {
+            readonly key: "i";
+            readonly code: "KeyI";
+            readonly keyCode: 73;
+        };
+        readonly KeyJ: {
+            readonly key: "j";
+            readonly code: "KeyJ";
+            readonly keyCode: 74;
+        };
+        readonly KeyK: {
+            readonly key: "k";
+            readonly code: "KeyK";
+            readonly keyCode: 75;
+        };
+        readonly KeyL: {
+            readonly key: "l";
+            readonly code: "KeyL";
+            readonly keyCode: 76;
+        };
+        readonly KeyM: {
+            readonly key: "m";
+            readonly code: "KeyM";
+            readonly keyCode: 77;
+        };
+        readonly KeyN: {
+            readonly key: "n";
+            readonly code: "KeyN";
+            readonly keyCode: 78;
+        };
+        readonly KeyO: {
+            readonly key: "o";
+            readonly code: "KeyO";
+            readonly keyCode: 79;
+        };
+        readonly KeyP: {
+            readonly key: "p";
+            readonly code: "KeyP";
+            readonly keyCode: 80;
+        };
+        readonly KeyQ: {
+            readonly key: "q";
+            readonly code: "KeyQ";
+            readonly keyCode: 81;
+        };
+        readonly KeyR: {
+            readonly key: "r";
+            readonly code: "KeyR";
+            readonly keyCode: 82;
+        };
+        readonly KeyS: {
+            readonly key: "s";
+            readonly code: "KeyS";
+            readonly keyCode: 83;
+        };
+        readonly KeyT: {
+            readonly key: "t";
+            readonly code: "KeyT";
+            readonly keyCode: 84;
+        };
+        readonly KeyU: {
+            readonly key: "u";
+            readonly code: "KeyU";
+            readonly keyCode: 85;
+        };
+        readonly KeyV: {
+            readonly key: "v";
+            readonly code: "KeyV";
+            readonly keyCode: 86;
+        };
+        readonly KeyW: {
+            readonly key: "w";
+            readonly code: "KeyW";
+            readonly keyCode: 87;
+        };
+        readonly KeyX: {
+            readonly key: "x";
+            readonly code: "KeyX";
+            readonly keyCode: 88;
+        };
+        readonly KeyY: {
+            readonly key: "y";
+            readonly code: "KeyY";
+            readonly keyCode: 89;
+        };
+        readonly KeyZ: {
+            readonly key: "z";
+            readonly code: "KeyZ";
+            readonly keyCode: 90;
+        };
+        readonly MetaLeft: {
+            readonly key: "Meta";
+            readonly code: "MetaLeft";
+            readonly keyCode: 91;
+        };
+        readonly ContextMenu: {
+            readonly key: "ContextMenu";
+            readonly code: "ContextMenu";
+            readonly keyCode: 93;
+        };
+        readonly Numpad0: {
+            readonly key: "0";
+            readonly code: "Numpad0";
+            readonly keyCode: 96;
+        };
+        readonly Numpad1: {
+            readonly key: "1";
+            readonly code: "Numpad1";
+            readonly keyCode: 97;
+        };
+        readonly Numpad2: {
+            readonly key: "2";
+            readonly code: "Numpad2";
+            readonly keyCode: 98;
+        };
+        readonly Numpad3: {
+            readonly key: "3";
+            readonly code: "Numpad3";
+            readonly keyCode: 99;
+        };
+        readonly Numpad4: {
+            readonly key: "4";
+            readonly code: "Numpad4";
+            readonly keyCode: 100;
+        };
+        readonly Numpad5: {
+            readonly key: "5";
+            readonly code: "Numpad5";
+            readonly keyCode: 101;
+        };
+        readonly Numpad6: {
+            readonly key: "6";
+            readonly code: "Numpad6";
+            readonly keyCode: 102;
+        };
+        readonly Numpad7: {
+            readonly key: "7";
+            readonly code: "Numpad7";
+            readonly keyCode: 103;
+        };
+        readonly Numpad8: {
+            readonly key: "8";
+            readonly code: "Numpad8";
+            readonly keyCode: 104;
+        };
+        readonly Numpad9: {
+            readonly key: "9";
+            readonly code: "Numpad9";
+            readonly keyCode: 105;
+        };
+        readonly NumpadMultiply: {
+            readonly key: "*";
+            readonly code: "NumpadMultiply";
+            readonly keyCode: 106;
+        };
+        readonly NumpadAdd: {
+            readonly key: "+";
+            readonly code: "NumpadAdd";
+            readonly keyCode: 107;
+        };
+        readonly NumpadSubtract: {
+            readonly key: "-";
+            readonly code: "NumpadSubtract";
+            readonly keyCode: 109;
+        };
+        readonly NumpadDecimal: {
+            readonly key: ".";
+            readonly code: "NumpadDecimal";
+            readonly keyCode: 110;
+        };
+        readonly NumpadDivide: {
+            readonly key: "/";
+            readonly code: "NumpadDivide";
+            readonly keyCode: 111;
+        };
+        readonly F1: {
+            readonly key: "F1";
+            readonly code: "F1";
+            readonly keyCode: 112;
+        };
+        readonly F2: {
+            readonly key: "F2";
+            readonly code: "F2";
+            readonly keyCode: 113;
+        };
+        readonly F3: {
+            readonly key: "F3";
+            readonly code: "F3";
+            readonly keyCode: 114;
+        };
+        readonly F4: {
+            readonly key: "F4";
+            readonly code: "F4";
+            readonly keyCode: 115;
+        };
+        readonly F5: {
+            readonly key: "F5";
+            readonly code: "F5";
+            readonly keyCode: 116;
+        };
+        readonly F6: {
+            readonly key: "F6";
+            readonly code: "F6";
+            readonly keyCode: 117;
+        };
+        readonly F7: {
+            readonly key: "F7";
+            readonly code: "F7";
+            readonly keyCode: 118;
+        };
+        readonly F8: {
+            readonly key: "F8";
+            readonly code: "F8";
+            readonly keyCode: 119;
+        };
+        readonly F9: {
+            readonly key: "F9";
+            readonly code: "F9";
+            readonly keyCode: 120;
+        };
+        readonly F10: {
+            readonly key: "F10";
+            readonly code: "F10";
+            readonly keyCode: 121;
+        };
+        readonly F11: {
+            readonly key: "F11";
+            readonly code: "F11";
+            readonly keyCode: 122;
+        };
+        readonly F12: {
+            readonly key: "F12";
+            readonly code: "F12";
+            readonly keyCode: 123;
+        };
+        readonly NumLock: {
+            readonly key: "NumLock";
+            readonly code: "NumLock";
+            readonly keyCode: 144;
+        };
+        readonly ScrollLock: {
+            readonly key: "ScrollLock";
+            readonly code: "ScrollLock";
+            readonly keyCode: 145;
+        };
+        readonly Semicolon: {
+            readonly key: ";";
+            readonly code: "Semicolon";
+            readonly keyCode: 186;
+        };
+        readonly Equal: {
+            readonly key: "=";
+            readonly code: "Equal";
+            readonly keyCode: 187;
+        };
+        readonly Comma: {
+            readonly key: ",";
+            readonly code: "Comma";
+            readonly keyCode: 188;
+        };
+        readonly Minus: {
+            readonly key: "-";
+            readonly code: "Minus";
+            readonly keyCode: 189;
+        };
+        readonly Period: {
+            readonly key: ".";
+            readonly code: "Period";
+            readonly keyCode: 190;
+        };
+        readonly Slash: {
+            readonly key: "/";
+            readonly code: "Slash";
+            readonly keyCode: 191;
+        };
+        readonly Backquote: {
+            readonly key: "`";
+            readonly code: "Backquote";
+            readonly keyCode: 192;
+        };
+        readonly BracketLeft: {
+            readonly key: "[";
+            readonly code: "BracketLeft";
+            readonly keyCode: 219;
+        };
+        readonly Backslash: {
+            readonly key: "\\";
+            readonly code: "Backslash";
+            readonly keyCode: 220;
+        };
+        readonly BracketRight: {
+            readonly key: "]";
+            readonly code: "BracketRight";
+            readonly keyCode: 221;
+        };
+        readonly Quote: {
+            readonly key: "'";
+            readonly code: "Quote";
+            readonly keyCode: 222;
+        };
+    };
+    Types: {
+        readonly INPUT_ZONE: "input-zone";
+        readonly TARGET_ZONE: "target-zone";
+        readonly BUTTON: "button";
+        readonly KEYBOARD_BUTTON: "keyboard-button";
+        readonly MOUSE_BUTTON: "mouse-button";
+        readonly JOYSTICK: "joystick";
+        readonly D_PAD: "d-pad";
+        readonly TRACKPAD: "trackpad";
+        readonly VIRTUAL_CURSOR: "virtual-cursor";
+        readonly ROOT_LAYER: "root-layer";
+    };
+};
+
+export { AbstractPointerEvent, AbstractRect, AnyFunction, type AxisLogicState, BaseConfig, BaseEntity, ButtonConfig, ButtonCore, type ButtonLogicState, type ButtonState, type CursorState, DPadConfig, DPadCore, type DPadState, EntityType, GamepadManager, GamepadMappingConfig, IConfigurable, ICoreEntity, IDependencyBindable, IObservable, IPointerHandler, IProgrammatic, type IRegistry, IResettable, ISignalReceiver, ISpatial, InputActionSignal, InputManager, InputZoneConfig, InputZoneCore, type InputZoneState, type InteractionState, JoystickConfig, JoystickCore, type JoystickState, type KeyboardButtonState, type LayerState, type MouseButtonState, OmniPad, Registry, RootLayerCore, TargetZoneConfig, TargetZoneCore, TrackpadConfig, TrackpadCore, type TrackpadState, Vec2 };