@omnipad/core 0.1.1-alpha.0

package/dist/index.d.mts

@@ -0,0 +1,1993 @@
+/**
+ * Interface defining the structure of a keyboard key mapping.
+ * Ensures compatibility between modern web standards and legacy Flash requirements.
+ */
+interface KeyMapping {
+    /**
+     * The key value, corresponding to `KeyboardEvent.key`.
+     * Represented as a string (e.g., " ", "Enter", "a").
+     */
+    key: string;
+    /**
+     * The physical key code, corresponding to `KeyboardEvent.code`.
+     * Describes the physical location of the key (e.g., "Space", "Enter", "KeyA").
+     */
+    code: string;
+    /**
+     * The legacy numerical key code, corresponding to `KeyboardEvent.keyCode`.
+     * Essential for Flash engines (AS2/AS3) running via Ruffle.
+     * e.g., 32 for Space, 13 for Enter.
+     */
+    keyCode: number;
+}
+/**
+ * Standard collection of key mappings.
+ * Allows developers to quickly retrieve mapping data using physical key codes as keys.
+ */
+declare const 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;
+    };
+};
+
+/**
+ * Defines the spatial properties of a component.
+ * Supports various CSS units (px, %, vh, vw) via FlexibleLength.
+ */
+interface LayoutBox {
+    /** Offset from the left edge of the parent container. */
+    left?: FlexibleLength;
+    /** Offset from the top edge of the parent container. */
+    top?: FlexibleLength;
+    /** Offset from the right edge of the parent container. */
+    right?: FlexibleLength;
+    /** Offset from the bottom edge of the parent container. */
+    bottom?: FlexibleLength;
+    /** Width of the component. */
+    width?: FlexibleLength;
+    /** Height of the component. */
+    height?: FlexibleLength;
+    /**
+     * The alignment point of the component relative to its (left, top) coordinates.
+     * @example 'center' will center the component on its position.
+     */
+    anchor?: AnchorPoint;
+    /** Rotation angle in degrees. */
+    /** Z-index for layering control. */
+    zIndex?: number;
+}
+/**
+ * Base configuration interface for all components.
+ */
+interface BaseConfig {
+    /**
+     * Config ID (CID) used in persistent storage.
+     * If omitted, a random UID will be generated during parsing.
+     * If starts with '$', it points to a global static entity. (UID = CID)
+     */
+    id?: string;
+    /** The unique type identifier for the component. */
+    type: string;
+    /** CID of the parent component. Root components have no parentId. */
+    parentId?: string;
+    /** Spatial layout settings. */
+    layout: LayoutBox;
+}
+/**
+ * Configuration for a virtual keyboard button.
+ */
+interface KeyboardButtonConfig extends BaseConfig {
+    type: typeof TYPES.KEYBOARD_BUTTON;
+    /** Visual text displayed on the button. */
+    label: string;
+    /** Keyboard event metadata to be emitted when triggered. */
+    mapping: KeyMapping;
+    /**
+     * CID of the TargetZone where signals should be dispatched.
+     */
+    targetStageId?: string;
+}
+/**
+ * Configuration for an Input Zone.
+ * Input Zones act as containers and can handle dynamic (floating) widgets.
+ */
+interface InputZoneConfig extends BaseConfig {
+    type: typeof TYPES.INPUT_ZONE;
+    /** If true, attempts to regain focus for the target stage when touched. */
+    preventFocusLoss?: boolean;
+    /**
+     * The CID of a child component intended to be used as a dynamic (floating) widget.
+     */
+    dynamicWidgetId?: string;
+}
+/**
+ * Configuration for a Target Focus Zone.
+ * Acts as the bridge between virtual signals and the actual game/app DOM.
+ */
+interface TargetZoneConfig extends BaseConfig {
+    type: typeof TYPES.TARGET_ZONE;
+    /** Whether to render a visual virtual cursor. */
+    cursorEnabled?: boolean;
+    /** Time in milliseconds before the cursor auto-hides after inactivity. 0 to disable. */
+    cursorAutoDelay?: number;
+}
+/**
+ * Union type representing any valid component configuration.
+ */
+type AnyConfig = KeyboardButtonConfig | InputZoneConfig | TargetZoneConfig | any;
+/**
+ * Representation of a single item in a flattened configuration profile.
+ * Ideal for database storage and flat-list editing.
+ */
+interface FlatConfigItem {
+    /** Unique identifier (CID) in the scope of the profile. */
+    id: string;
+    /** Component type string. */
+    type: string;
+    /** Parent CID. Empty if this is the root node. */
+    parentId?: string;
+    /** Flattened business logic and layout properties. */
+    config?: Record<string, any>;
+}
+/**
+ * The root structure of a Gamepad configuration file.
+ */
+interface GamepadProfile {
+    /** Metadata about the profile creator and version. */
+    meta: {
+        name: string;
+        version: string;
+        author?: string;
+    };
+    /** The CID of the entry-point component (usually a root layer or zone, or widget for individual widget config). */
+    rootId: string;
+    /** List of all components in the profile. Hierarchies are defined via parentId. */
+    items: FlatConfigItem[];
+}
+/**
+ * A recursive tree structure representing the runtime hierarchy of components.
+ * Used by the adapter layer (e.g., Vue) to render components recursively.
+ */
+interface ConfigTreeNode {
+    /** Runtime Unique Entity ID (UID), unique across the entire application. */
+    uid: string;
+    /** Component type string. */
+    type: string;
+    /** Component properties (layout, mapping, etc.), stripped of hierarchy data. */
+    config?: Record<string, any>;
+    /** Nested children tree nodes. */
+    children?: ConfigTreeNode[];
+}
+
+/**
+ * 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 joystick-type widgets.
+ * Provides directional data calculated from the stick movement.
+ */
+interface JoystickLogicState {
+    /** Normalized direction vector where x and y range from -1.0 to 1.0. */
+    vector: {
+        x: number;
+        y: number;
+    };
+    /** The current angle of the stick in radians. */
+    angle: 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 Keyboard Button components.
+ */
+interface KeyboardButtonState extends InteractionState, ButtonLogicState {
+}
+/**
+ * Combined state for Analog Stick components.
+ */
+interface JoystickState extends InteractionState, JoystickLogicState {
+}
+
+/**
+ * Trait: Provides identity with a unique ID and specific entity type.
+ */
+interface IIdentifiable {
+    readonly uid: string;
+    readonly type: EntityType;
+}
+/**
+ * Trait: Provides lifecycle management hooks.
+ */
+interface ILifecycle {
+    /**
+     * Performs cleanup, unregisters the entity, and releases resources.
+     */
+    destroy(): void;
+}
+/**
+ * The core contract for any object that can be managed by the Registry.
+ * Only objects implementing this interface are eligible for registration.
+ */
+interface ICoreEntity extends IIdentifiable, ILifecycle {
+}
+/**
+ * Trait: Enables spatial awareness for DOM/UI-related components.
+ */
+interface ISpatial {
+    /**
+     * Updates the physical boundary rect, usually called by a ResizeObserver in the adapter layer.
+     * @param rect - The new DOMRect of the element.
+     */
+    updateRect(rect: DOMRect): void;
+}
+/**
+ * Trait: Provides configuration management.
+ */
+interface IConfigurable<TConfig> {
+    /**
+     * Dynamically updates the current configuration.
+     * @param config - Partial configuration object to merge.
+     */
+    updateConfig(config: Partial<TConfig>): void;
+    /**
+     * Retrieves a snapshot of the current configuration.
+     */
+    getConfig(): TConfig;
+}
+/**
+ * Trait: Enables state subscription for the adapter layer (e.g., Vue/React).
+ */
+interface IObservable<TState> {
+    /**
+     * Subscribes to state changes.
+     * @param cb - Callback function triggered on state updates.
+     * @returns An unsubscribe function.
+     */
+    subscribe(cb: (state: TState) => void): () => void;
+    /**
+     * Retrieves the current state snapshot.
+     */
+    getState(): TState;
+}
+/**
+ * Trait: Allows resetting the entity to its idle/safe state.
+ */
+interface IResettable {
+    /**
+     * Forcefully clears active states and cuts off outgoing signals.
+     */
+    reset(): void;
+}
+/**
+ * Trait: Handles raw pointer input (Touch/Mouse).
+ */
+interface IPointerHandler {
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+}
+/**
+ * Trait: Receives and processes input signals (e.g., TargetZone).
+ */
+interface ISignalReceiver {
+    /**
+     * Handles incoming signals from widgets.
+     * @param signal - The signal data containing action type and payload.
+     */
+    handleSignal(signal: InputActionSignal): void;
+}
+
+/**
+ * =================================================================
+ * 1. Constants Definition
+ * Used for runtime logic and as a baseline for type definitions.
+ * =================================================================
+ */
+/**
+ * Core entity types supported by the library.
+ */
+declare const TYPES: {
+    /** Area responsible for capturing touches and spawning dynamic widgets */
+    readonly INPUT_ZONE: "input-zone";
+    /** Area responsible for receiving signals and simulating DOM events */
+    readonly TARGET_ZONE: "target-zone";
+    /** Simulates a physical keyboard key press */
+    readonly KEYBOARD_BUTTON: "keyboard-button";
+    /** Simulates a mouse button click/hold */
+    readonly MOUSE_BUTTON: "mouse-button";
+    /** A joystick that outputs 360-degree or locked direction vectors */
+    readonly ANALOG_STICK: "analog-stick";
+    /** Classic 4/8-way directional pad */
+    readonly D_PAD: "d-pad";
+    /** Trackpad-style relative movement area */
+    readonly TRACKPAD: "trackpad";
+    /** Logic for the on-screen visual cursor */
+    readonly VIRTUAL_CURSOR: "virtual-cursor";
+    /** The top-level managed container */
+    readonly ROOT_LAYER: "root-layer";
+};
+/**
+ * Standardized input action types for the signal protocol.
+ */
+declare const ACTION_TYPES: {
+    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";
+};
+/**
+ * =================================================================
+ * 2. Type Definitions
+ * =================================================================
+ */
+/**
+ * Represents a 2D coordinate or vector.
+ * Typically used for percentage-based positioning (0-100).
+ */
+interface Vec2 {
+    x: number;
+    y: number;
+}
+/** Unique identifier for a Stage (TargetZone) */
+type StageId = string;
+/** Unique identifier for an Input Widget */
+type WidgetId = string;
+/** Unique identifier for a Zone container (InputZone) */
+type ZoneId = string;
+/** Union type of all built-in entity values */
+type AnyEntityType = (typeof TYPES)[keyof typeof TYPES];
+/** Supported Widget type strings, allowing for custom string extensions */
+type WidgetType = typeof TYPES.KEYBOARD_BUTTON | typeof TYPES.MOUSE_BUTTON | typeof TYPES.ANALOG_STICK | typeof TYPES.D_PAD | typeof TYPES.TRACKPAD | (string & {});
+/** Supported Zone type strings, allowing for custom string extensions */
+type ZoneType = typeof TYPES.INPUT_ZONE | typeof TYPES.TARGET_ZONE | (string & {});
+/** General node type identifier for ConfigTreeNode or Registry lookups */
+type EntityType = AnyEntityType | (string & {});
+/** Built-in input action identifiers */
+type BuiltInActionType = (typeof ACTION_TYPES)[keyof typeof ACTION_TYPES];
+/** Input action type strings, allowing for custom action extensions */
+type InputActionType = BuiltInActionType | (string & {});
+/** Supported CSS units for layout calculation */
+type Unit = 'px' | '%' | 'vh' | 'vw' | 'rem';
+/**
+ * Flexible length input.
+ * Supports numbers (interpreted as px) or strings (e.g., '50%', '10vh').
+ */
+type FlexibleLength = string | number;
+/**
+ * Anchor position used to determine the alignment of an element relative to its coordinates.
+ */
+type AnchorPoint = 'top-left' | 'top-center' | 'top-right' | 'center-left' | 'center' | 'center-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+/**
+ * =================================================================
+ * 3. Signal Protocol
+ * Data structure for communication between Widgets and Stages.
+ * =================================================================
+ */
+/**
+ * Represents a signal emitted by an input widget to be processed by a target zone.
+ */
+interface InputActionSignal {
+    /** The unique identifier of the destination TargetZone */
+    targetStageId: StageId;
+    /** The action type to perform (e.g., keydown, mousemove) */
+    type: InputActionType;
+    /** The payload containing specific input details */
+    payload: {
+        /** Character value of the key (e.g., ' ') */
+        key?: string;
+        /** Physical key code (e.g., 'Space') */
+        code?: string;
+        /** Legacy numeric key code (e.g., 32) */
+        keyCode?: number;
+        /** Coordinate point in percentage (0-100) */
+        point?: Vec2;
+        /** Mouse button index (0: Left, 1: Middle, 2: Right) */
+        button?: 0 | 1 | 2;
+        /** Input pressure or force (0.0 to 1.0) */
+        pressure?: number;
+        /** Allows for arbitrary custom data to support widget extensions */
+        [key: string]: any;
+    };
+}
+/**
+ * Cross-framework context keys for dependency injection (e.g., Provide/Inject).
+ */
+declare const CONTEXT: {
+    /** The key used to propagate Parent IDs through the component tree */
+    readonly PARENT_ID_KEY: "omnipad-parent-id-link";
+};
+
+/**
+ * Subtracts vector v2 from v1.
+ * @param v1 - The source vector.
+ * @param v2 - The vector to subtract.
+ */
+declare const subVec: (v1: Vec2, v2: Vec2) => Vec2;
+/**
+ * Adds vector v2 to v1.
+ */
+declare const addVec: (v1: Vec2, v2: Vec2) => Vec2;
+/**
+ * Scales a vector by a scalar value.
+ * Useful for mapping normalized vectors back to specific pixel magnitudes.
+ */
+declare const scaleVec: (v: Vec2, s: number) => Vec2;
+/**
+ * Clamps a numeric value between a minimum and maximum range.
+ */
+declare const clamp: (val: number, min: number, max: number) => number;
+/**
+ * Linearly interpolates between two values.
+ */
+declare const lerp: (start: number, end: number, t: number) => number;
+/**
+ * Rounds a number to a specific decimal precision.
+ * Solves floating-point precision issues in pixel calculations.
+ */
+declare const roundTo: (val: number, precision?: number) => number;
+/**
+ * Calculates the Euclidean distance between two points.
+ */
+declare const getDistance: (p1: Vec2, p2: Vec2) => number;
+/**
+ * Calculates the angle in radians from point p1 to p2.
+ * Range: -PI to PI.
+ */
+declare const getAngle: (p1: Vec2, p2: Vec2) => number;
+/**
+ * Converts radians to degrees.
+ */
+declare const radToDeg: (rad: number) => number;
+/**
+ * Converts degrees to radians.
+ */
+declare const degToRad: (deg: number) => number;
+/**
+ * Constrains a target point within a circular radius relative to an origin.
+ * Commonly used for joystick physical displacement limits.
+ */
+declare const clampVector: (origin: Vec2, target: Vec2, radius: number) => Vec2;
+/**
+ * Snaps a radian angle to the nearest of 8 directions (45-degree steps).
+ */
+declare const lockTo8Directions: (rad: number) => number;
+/**
+ * Snaps a radian angle to the nearest of 4 directions (90-degree steps).
+ */
+declare const lockTo4Directions: (rad: number) => number;
+/**
+ * Converts percentage (0-100) to pixel values (px).
+ */
+declare const percentToPx: (percent: number, totalPx: number) => number;
+/**
+ * Converts pixel values (px) to percentage (0-100).
+ */
+declare const pxToPercent: (px: number, totalPx: number) => number;
+/**
+ * Normalizes a vector to a length of 1.
+ * Returns {0, 0} if the vector magnitude is 0.
+ */
+declare const normalizeVec: (v: Vec2) => Vec2;
+/**
+ * Converts a radian angle to a unit vector.
+ */
+declare const radToVec: (rad: number) => Vec2;
+/**
+ * Linearly remaps a value from one range [inMin, inMax] to another [outMin, outMax].
+ */
+declare const remap: (val: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
+/**
+ * Performs a dirty check to see if two Vec2 points are different within an epsilon.
+ */
+declare const isVec2Equal: (v1: Vec2, v2: Vec2, epsilon?: number) => boolean;
+/**
+ * Core deadzone logic.
+ * Maps a value from [threshold, max] to a normalized scale [0, 1].
+ * @returns A scalar value between 0 and 1.
+ */
+declare const getDeadzoneScalar: (magnitude: number, threshold: number, max: number) => number;
+/**
+ * Applies a radial deadzone to a vector.
+ * Suitable for analog sticks to ensure a smooth transition from center.
+ * @param v - Input vector.
+ * @param radius - The total radius of the joystick base.
+ * @param deadzonePercent - Deadzone threshold (0.0 to 1.0).
+ */
+declare const applyRadialDeadzone: (v: Vec2, radius: number, deadzonePercent: number) => Vec2;
+/**
+ * Applies an axial deadzone to a vector.
+ * Independently processes X and Y axes. Useful for D-Pads or precision directional inputs.
+ * @param v - Input vector.
+ * @param threshold - The deadzone threshold value.
+ * @param max - Maximum value for the axis.
+ */
+declare const applyAxialDeadzone: (v: Vec2, threshold: number, max: number) => Vec2;
+
+/**
+ * Recursively penetrates Shadow DOM boundaries to find the deepest element at the
+ * specified viewport coordinates.
+ *
+ * @param x - Viewport X coordinate (px)
+ * @param y - Viewport Y coordinate (px)
+ * @returns The deepmost Element or null if none found at the position.
+ */
+declare const getDeepElement: (x: number, y: number) => Element | null;
+/**
+ * Recursively finds the truly focused element by traversing Shadow DOM boundaries.
+ *
+ * @returns The deepmost active Element in focus or null.
+ */
+declare const getDeepActiveElement: () => Element | null;
+/**
+ * Forcefully focuses an element.
+ * Automatically handles the 'tabindex' attribute to ensure non-focusable elements (like Canvas)
+ * can receive focus.
+ *
+ * @param el - The target HTMLElement to focus.
+ */
+declare const focusElement: (el: HTMLElement) => void;
+/**
+ * Dispatches a synthetic KeyboardEvent to the window object.
+ *
+ * @param type - The event type, e.g., 'keydown' or 'keyup'.
+ * @param payload - Key mapping data including key, code, and legacy keyCode.
+ */
+declare const dispatchKeyboardEvent: (type: string, payload: {
+    key: string;
+    code: string;
+    keyCode: number;
+}) => void;
+/**
+ * Dispatches a high-fidelity sequence of Pointer and Mouse events at specific pixel coordinates.
+ * Finds the target element dynamically at the moment of dispatch.
+ *
+ * @param type - The event type (should start with 'pointer' for best compatibility).
+ * @param x - Viewport X coordinate (px).
+ * @param y - Viewport Y coordinate (px).
+ * @param opts - Additional PointerEvent options (button, pressure, etc.).
+ */
+declare const dispatchPointerEventAtPos: (type: string, x: number, y: number, opts?: PointerEventInit) => void;
+/**
+ * Calculates the pixel coordinate of an anchor point within a given DOMRect.
+ * Used to translate relative layout definitions into screen-space pixels.
+ *
+ * @param rect - The bounding box of the container.
+ * @param anchor - The defined anchor point (e.g., 'center', 'top-left').
+ * @returns The absolute viewport coordinates {x, y}.
+ */
+declare const getAnchorPosition: (rect: DOMRect, anchor: AnchorPoint) => Vec2;
+
+/**
+ * Generates a globally unique identifier (UID) for runtime entity management and DOM keys.
+ *
+ * The generated ID follows the format: `[prefix]-[timestamp_base36]-[random_string]`.
+ * This ensures that components generated at different times or across multiple sessions
+ * remain unique within the current page instance.
+ *
+ * @param prefix - A string prefix for the ID, typically the component type (e.g., 'btn', 'joy'). Defaults to 'omnipad'.
+ * @returns A unique string identifier.
+ *
+ * @example
+ * generateUID('button') // returns "button-m7x8k1p2-f4k2"
+ */
+declare const generateUID: (prefix?: string) => string;
+/**
+ * Checks if the provided ID is a reserved global identifier.
+ *
+ * In OmniPad, IDs starting with the `$` symbol are considered "Global IDs".
+ * These identifiers are treated as static references and are not transformed
+ * into dynamic UIDs during configuration parsing.
+ *
+ * @param id - The identifier string to check.
+ * @returns `true` if the ID starts with `$`, otherwise `false`.
+ *
+ * @example
+ * isGlobalID('$root-layer') // returns true
+ * isGlobalID('btn-up')      // returns false
+ */
+declare function isGlobalID(id: string): boolean;
+
+/**
+ * Converts a LayoutBox configuration into a CSS style object suitable for Vue/React.
+ *
+ * This utility handles:
+ * 1. Unit normalization: Converts numeric values to 'px' strings while preserving unit strings (vh, %, etc.).
+ * 2. Positioning: Sets 'absolute' positioning by default.
+ * 3. Anchoring: Maps AnchorPoint values to CSS 'transform' translations to ensure
+ *    the component's origin matches its defined coordinates.
+ *
+ * @param layout - The LayoutBox configuration object.
+ * @returns A CSS style record object.
+ *
+ * @example
+ * // returns { position: 'absolute', left: '50%', top: '50%', transform: 'translate(-50%, -50%)' }
+ * resolveLayoutStyle({ left: '50%', top: '50%', anchor: 'center' });
+ */
+declare const resolveLayoutStyle: (layout: LayoutBox) => Record<string, string | number>;
+
+/**
+ * Validates and normalizes raw JSON data into a standard GamepadProfile.
+ * Performs structural checks and injects default metadata.
+ *
+ * @param raw - The raw JSON object from disk or network.
+ * @returns A validated GamepadProfile object.
+ * @throws Error if the core structure is invalid.
+ */
+declare function parseProfileJson(raw: any): GamepadProfile;
+/**
+ * Converts a flat GamepadProfile into a hierarchical ConfigTreeNode tree for runtime rendering.
+ * Handles CID (Config ID) to UID (Entity ID) mapping and reference resolution.
+ *
+ * @param profile - The normalized profile data.
+ * @returns The root node of the configuration tree.
+ */
+declare function parseProfileTree(profile: GamepadProfile): ConfigTreeNode;
+/**
+ * Serializes the current runtime entities from the Registry back into a flat GamepadProfile.
+ * Generates fresh Config IDs (CIDs) for all nodes except global IDs.
+ *
+ * @param meta - Metadata for the exported profile.
+ * @param rootUid - The Entity ID of the node to be treated as the root.
+ * @returns A flat GamepadProfile ready for storage.
+ */
+declare function exportProfile(meta: GamepadProfile['meta'], rootUid: string): GamepadProfile;
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+    private constructor();
+    /**
+     * Retrieves the global instance of the InputManager.
+     * Ensures uniqueness across multiple bundles or modules.
+     */
+    static getInstance(): InputManager;
+    /**
+     * Initializes global safety listeners.
+     * Should be called once at the root component lifecycle (e.g., VirtualLayer).
+     */
+    init(): void;
+    /**
+     * Manually triggers a system-wide input reset via Registry.
+     */
+    private handleGlobalReset;
+    /**
+     * 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;
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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>;
+}
+
+/**
+ * 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 rect: DOMRect | 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;
+    updateRect(rect: DOMRect): void;
+    updateConfig(newConfig: Partial<TConfig>): void;
+    getState(): Readonly<TState>;
+    getConfig(): Readonly<TConfig>;
+}
+
+/**
+ * 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 {
+    constructor(uid: string, config: InputZoneConfig);
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+    /**
+     * Internal helper to handle pointer release and cleanup.
+     */
+    private handleRelease;
+    /**
+     * Converts viewport pixels to percentage coordinates relative to the zone.
+     */
+    private calculateRelativePosition;
+    /**
+     * Whether the interceptor layer should be enabled.
+     */
+    get isInterceptorRequired(): boolean;
+    reset(): void;
+}
+
+/**
+ * Core logic implementation for a keyboard button widget.
+ * Handles pointer interactions and translates them into keyboard signals for a target stage.
+ */
+declare class KeyboardButtonCore extends BaseEntity<KeyboardButtonConfig, KeyboardButtonState> implements IPointerHandler {
+    /**
+     * Creates an instance of KeyboardButtonCore.
+     *
+     * @param uid - The unique entity ID.
+     * @param config - The flat configuration object for the button.
+     */
+    constructor(uid: string, config: KeyboardButtonConfig);
+    onPointerDown(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    /**
+     * Common logic for releasing the button state.
+     *
+     * @param e - The pointer event that triggered the release.
+     */
+    private handleRelease;
+    /**
+     * Dispatches input signals to the registered target stage.
+     *
+     * @param type - The action type (keydown or keyup).
+     */
+    private sendInputSignal;
+    reset(): 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 ISignalReceiver {
+    private hideTimer;
+    private focusFeedbackTimer;
+    constructor(uid: string, config: TargetZoneConfig);
+    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;
+    /**
+     * Makes the virtual cursor visible and sets a timeout for auto-hiding.
+     */
+    private showCursor;
+    reset(): void;
+}
+
+declare const OmniPad: {
+    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 KEYBOARD_BUTTON: "keyboard-button";
+        readonly MOUSE_BUTTON: "mouse-button";
+        readonly ANALOG_STICK: "analog-stick";
+        readonly D_PAD: "d-pad";
+        readonly TRACKPAD: "trackpad";
+        readonly VIRTUAL_CURSOR: "virtual-cursor";
+        readonly ROOT_LAYER: "root-layer";
+    };
+};
+
+export { ACTION_TYPES, type AnchorPoint, type AnyConfig, type AnyEntityType, type BaseConfig, BaseEntity, type BuiltInActionType, type ButtonLogicState, CONTEXT, type ConfigTreeNode, type CursorState, type EntityType, type FlatConfigItem, type FlexibleLength, type GamepadProfile, type IConfigurable, type ICoreEntity, type IIdentifiable, type ILifecycle, type IObservable, type IPointerHandler, type IResettable, type ISignalReceiver, type ISpatial, type InputActionSignal, type InputActionType, InputManager, type InputZoneConfig, InputZoneCore, type InputZoneState, type InteractionState, type JoystickLogicState, type JoystickState, KEYS, type KeyMapping, type KeyboardButtonConfig, KeyboardButtonCore, type KeyboardButtonState, type LayerState, type LayoutBox, type Listener, OmniPad, Registry, RootLayerCore, SimpleEmitter, type StageId, TYPES, type TargetZoneConfig, TargetZoneCore, type Unit, type Vec2, type WidgetId, type WidgetType, type ZoneId, type ZoneType, addVec, applyAxialDeadzone, applyRadialDeadzone, clamp, clampVector, degToRad, dispatchKeyboardEvent, dispatchPointerEventAtPos, exportProfile, focusElement, generateUID, getAnchorPosition, getAngle, getDeadzoneScalar, getDeepActiveElement, getDeepElement, getDistance, isGlobalID, isVec2Equal, lerp, lockTo4Directions, lockTo8Directions, normalizeVec, parseProfileJson, parseProfileTree, percentToPx, pxToPercent, radToDeg, radToVec, remap, resolveLayoutStyle, roundTo, scaleVec, subVec };