blecsd 0.1.1 → 0.3.0

package/dist/{inputActions-CefRUBuT.d.ts → inputActions-CRsUtTHM.d.ts}

@@ -1,13 +1,11 @@
 import { z } from 'zod';
-import { f as BorderCharset } from './border-D_Jb4ZJV.js';
-import { W as World, E as Entity } from './types-BcsvoKzf.js';
+import { h as BorderCharset } from './border-Jb7TrMob.js';
 import { M as MouseEvent, c as MouseButton } from './mouseParser-Cfrbn3AX.js';
-import { b as KeyEvent, K as KeyName } from './keyParser-Bwm8-l7v.js';
+import { b as KeyEvent, K as KeyName } from './keyParser-BnHbg2iD.js';
 
 /**
- * Entity factory functions for creating common entity types.
- * These are internal factories used by the Game class.
- * @module core/entities
+ * Zod validation schemas and TypeScript types for entity configurations.
+ * @module core/entities/schemas
  */
 
 /**
@@ -1138,715 +1136,6 @@ declare const RadioButtonConfigSchema: z.ZodObject<{
  * @see {@link createRadioButtonEntity} for entity creation
  */
 type RadioButtonConfig = z.infer<typeof RadioButtonConfigSchema>;
-/**
- * Creates a Box entity with the specified configuration.
- *
- * Box is a basic container element with position, dimensions, optional border,
- * and padding. Boxes serve as the foundation for layout and grouping other
- * elements in the UI hierarchy.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional box configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createBoxEntity, BorderType } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple box
- * const box = createBoxEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 40,
- *   height: 10,
- * });
- *
- * // Create a styled box with border
- * const styledBox = createBoxEntity(world, {
- *   x: 0,
- *   y: 0,
- *   width: 20,
- *   height: 5,
- *   fg: 0xffffffff,
- *   bg: 0x0000ffff,
- *   border: {
- *     type: BorderType.Line,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- *   padding: {
- *     left: 1,
- *     right: 1,
- *     top: 0,
- *     bottom: 0,
- *   },
- * });
- *
- * // Create a child box
- * const childBox = createBoxEntity(world, {
- *   parent: styledBox,
- *   x: 2,
- *   y: 1,
- *   width: 10,
- *   height: 3,
- * });
- * ```
- */
-declare function createBoxEntity(world: World, config?: BoxConfig): Entity;
-/**
- * Creates a Text entity with the specified configuration.
- *
- * Text entities display content with optional styling, border, and text alignment.
- * They support text wrapping, vertical and horizontal alignment, and tag parsing
- * for inline styling.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional text configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createTextEntity, TextAlign, TextVAlign } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create simple text
- * const text = createTextEntity(world, {
- *   x: 5,
- *   y: 2,
- *   text: 'Hello, World!',
- * });
- *
- * // Create styled, centered text
- * const styledText = createTextEntity(world, {
- *   x: 0,
- *   y: 0,
- *   width: 40,
- *   height: 3,
- *   text: 'Centered Title',
- *   fg: 0x00ff00ff,
- *   align: TextAlign.Center,
- *   valign: TextVAlign.Middle,
- * });
- *
- * // Create wrapped text block
- * const paragraph = createTextEntity(world, {
- *   x: 5,
- *   y: 10,
- *   width: 60,
- *   text: 'This is a long paragraph that will wrap to fit within the specified width.',
- *   wrap: true,
- * });
- * ```
- */
-declare function createTextEntity(world: World, config?: TextConfig): Entity;
-/**
- * Creates a Button entity with the specified configuration.
- *
- * Button entities are interactive elements with focus support, hover effects,
- * and click handling. They display a centered label and respond to keyboard
- * and mouse input. Buttons are focusable, clickable, and hoverable by default.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional button configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createButtonEntity, BorderType } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple button
- * const button = createButtonEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 12,
- *   height: 3,
- *   label: 'Submit',
- * });
- *
- * // Create a styled button with border
- * const styledButton = createButtonEntity(world, {
- *   x: 10,
- *   y: 10,
- *   width: 16,
- *   height: 3,
- *   label: 'Cancel',
- *   fg: 0xffffffff,
- *   bg: 0xff0000ff,
- *   hoverEffectFg: 0xffffffff,
- *   hoverEffectBg: 0xff4444ff,
- *   focusEffectFg: 0xffffffff,
- *   focusEffectBg: 0x0066ffff,
- *   border: {
- *     type: BorderType.Line,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- * });
- *
- * // Create a button with custom tab order
- * const tabButton = createButtonEntity(world, {
- *   x: 30,
- *   y: 5,
- *   label: 'Next',
- *   tabIndex: 2,
- * });
- * ```
- */
-declare function createButtonEntity(world: World, config?: ButtonConfig): Entity;
-/**
- * Creates a Screen entity with the specified configuration.
- *
- * Screen entities are the root container for all other entities. They represent
- * the terminal viewport and define the coordinate space for child elements.
- * Screens are always positioned at (0,0) and are always visible.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Screen configuration with required width and height
- * @returns The created entity ID
- * @throws {ZodError} If width or height are missing or not positive integers
- *
- * @example
- * ```typescript
- * import { createWorld, createScreenEntity } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a screen matching terminal size
- * const screen = createScreenEntity(world, {
- *   width: 80,
- *   height: 24,
- * });
- *
- * // Create a screen with title
- * const namedScreen = createScreenEntity(world, {
- *   width: 120,
- *   height: 40,
- *   title: 'My Terminal Game',
- * });
- * ```
- */
-declare function createScreenEntity(world: World, config: ScreenConfig): Entity;
-/**
- * Creates an Input entity with the specified configuration.
- *
- * Input entities are text input fields with focus and key handling.
- * They support placeholder text, maximum length constraints, and visual
- * feedback for focus and hover states. Inputs are focusable, clickable,
- * and keyable by default.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional input configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createInputEntity, BorderType } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple input
- * const input = createInputEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 30,
- *   height: 1,
- * });
- *
- * // Create an input with placeholder and validation
- * const emailInput = createInputEntity(world, {
- *   x: 10,
- *   y: 8,
- *   width: 40,
- *   height: 1,
- *   value: '',
- *   placeholder: 'Enter your email...',
- *   maxLength: 100,
- * });
- *
- * // Create a styled input with custom focus colors
- * const styledInput = createInputEntity(world, {
- *   x: 10,
- *   y: 11,
- *   width: 30,
- *   height: 1,
- *   focusEffectFg: 0x00ff00ff,
- *   focusEffectBg: 0x111111ff,
- *   border: {
- *     type: BorderType.Line,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- * });
- * ```
- */
-declare function createInputEntity(world: World, config?: InputConfig): Entity;
-/**
- * Creates a List entity with the specified configuration.
- *
- * List entities display a scrollable list of items with selection support.
- * They are focusable, respond to keyboard navigation, and support configurable
- * scrollbar visibility. Items are stored as newline-separated content.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional list configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createListEntity, BorderType } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple list
- * const list = createListEntity(world, {
- *   x: 5,
- *   y: 5,
- *   width: 30,
- *   height: 10,
- *   items: ['Option 1', 'Option 2', 'Option 3'],
- * });
- *
- * // Create a list with selection and scrolling
- * const menuList = createListEntity(world, {
- *   x: 0,
- *   y: 0,
- *   width: 25,
- *   height: 8,
- *   items: ['New Game', 'Load Game', 'Options', 'Credits', 'Exit'],
- *   selectedIndex: 0,
- *   scrollable: true,
- *   border: {
- *     type: BorderType.Line,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- * });
- *
- * // Create a list with custom focus styling
- * const styledList = createListEntity(world, {
- *   x: 30,
- *   y: 5,
- *   width: 20,
- *   height: 6,
- *   items: ['Red', 'Green', 'Blue'],
- *   focusEffectFg: 0xffff00ff,
- *   focusEffectBg: 0x333333ff,
- *   tabIndex: 1,
- * });
- * ```
- */
-declare function createListEntity(world: World, config?: ListConfig): Entity;
-/**
- * Creates a Checkbox entity with the specified configuration.
- *
- * Checkbox entities are toggle controls with checked/unchecked/disabled states.
- * They support keyboard interaction (Enter/Space to toggle), focus handling,
- * and customizable display characters. Checkboxes are focusable, clickable,
- * and keyable by default.
- *
- * The checkbox displays a check character followed by an optional label.
- * The display characters can be customized to use ASCII or Unicode symbols.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional checkbox configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createCheckboxEntity } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple checkbox
- * const checkbox = createCheckboxEntity(world, {
- *   x: 5,
- *   y: 10,
- *   label: 'Enable notifications',
- * });
- *
- * // Create a pre-checked checkbox
- * const acceptTerms = createCheckboxEntity(world, {
- *   x: 5,
- *   y: 12,
- *   label: 'I accept the terms and conditions',
- *   checked: true,
- * });
- *
- * // Create a checkbox with ASCII characters
- * const asciiCheckbox = createCheckboxEntity(world, {
- *   x: 5,
- *   y: 14,
- *   label: 'Use ASCII mode',
- *   checkedChar: '[x]',
- *   uncheckedChar: '[ ]',
- * });
- *
- * // Create a styled checkbox with custom focus colors
- * const styledCheckbox = createCheckboxEntity(world, {
- *   x: 5,
- *   y: 16,
- *   label: 'Dark mode',
- *   focusEffectFg: 0x00ff00ff,
- *   focusEffectBg: 0x111111ff,
- *   tabIndex: 1,
- * });
- * ```
- */
-declare function createCheckboxEntity(world: World, config?: CheckboxConfig): Entity;
-/**
- * Creates a Textbox entity with the specified configuration.
- *
- * Textbox entities are single-line text input fields with cursor support,
- * password masking, placeholder text, and keyboard navigation. They support
- * Enter to submit, Escape to cancel, and standard text editing keys
- * (Backspace, Delete, Left/Right arrows, Home/End).
- *
- * Textboxes are focusable, clickable, and keyable by default.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional textbox configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createTextboxEntity } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple textbox
- * const textbox = createTextboxEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 30,
- *   height: 1,
- * });
- *
- * // Create a textbox with placeholder
- * const nameInput = createTextboxEntity(world, {
- *   x: 10,
- *   y: 8,
- *   width: 40,
- *   height: 1,
- *   placeholder: 'Enter your name...',
- *   maxLength: 50,
- * });
- *
- * // Create a password field
- * const passwordInput = createTextboxEntity(world, {
- *   x: 10,
- *   y: 11,
- *   width: 30,
- *   height: 1,
- *   secret: true,
- *   censor: '*',
- *   placeholder: 'Password',
- * });
- *
- * // Create a styled textbox with custom focus colors
- * const styledTextbox = createTextboxEntity(world, {
- *   x: 10,
- *   y: 14,
- *   width: 30,
- *   height: 1,
- *   value: 'Initial value',
- *   focusEffectFg: 0x00ff00ff,
- *   focusEffectBg: 0x111111ff,
- *   border: {
- *     type: 1,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- * });
- * ```
- */
-declare function createTextboxEntity(world: World, config?: TextboxConfig): Entity;
-/**
- * Creates a Textarea entity with the specified configuration.
- *
- * Textarea entities are multi-line text input fields with cursor support,
- * placeholder text, scrolling, and keyboard navigation. They support
- * Enter for new lines, Escape or Ctrl+Enter to submit, and standard text
- * editing keys (Backspace, Delete, Left/Right/Up/Down arrows, Home/End).
- *
- * Textareas are focusable, clickable, and keyable by default.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional textarea configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createTextareaEntity } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple textarea
- * const textarea = createTextareaEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 40,
- *   height: 5,
- * });
- *
- * // Create a textarea with placeholder
- * const messageInput = createTextareaEntity(world, {
- *   x: 10,
- *   y: 12,
- *   width: 50,
- *   height: 8,
- *   placeholder: 'Enter your message...',
- *   scrollable: true,
- * });
- *
- * // Create a styled textarea with border
- * const styledTextarea = createTextareaEntity(world, {
- *   x: 10,
- *   y: 22,
- *   width: 50,
- *   height: 10,
- *   value: 'Initial content\nwith multiple lines',
- *   maxLength: 500,
- *   focusEffectFg: 0x00ff00ff,
- *   focusEffectBg: 0x111111ff,
- *   border: {
- *     type: 1,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- * });
- * ```
- */
-declare function createTextareaEntity(world: World, config?: TextareaConfig): Entity;
-/**
- * Creates a Select/Dropdown entity with the specified configuration.
- *
- * Select entities are dropdown controls with a list of options.
- * They support click to open, keyboard navigation (Up/Down to navigate,
- * Enter/Space to select, Escape to close), and customizable display.
- *
- * Selects are focusable, clickable, and keyable by default.
- *
- * @param world - The ECS world to create the entity in
- * @param config - Optional select configuration options
- * @returns The created entity ID
- *
- * @example
- * ```typescript
- * import { createWorld, createSelectEntity, onSelectChange } from 'blecsd';
- *
- * const world = createWorld();
- *
- * // Create a simple select
- * const select = createSelectEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 30,
- *   options: [
- *     { label: 'Red', value: 'red' },
- *     { label: 'Green', value: 'green' },
- *     { label: 'Blue', value: 'blue' },
- *   ],
- *   selectedIndex: 0,
- * });
- *
- * // Create a select with placeholder
- * const colorPicker = createSelectEntity(world, {
- *   x: 10,
- *   y: 8,
- *   width: 30,
- *   options: [
- *     { label: 'Primary', value: 'primary' },
- *     { label: 'Secondary', value: 'secondary' },
- *     { label: 'Accent', value: 'accent' },
- *   ],
- *   placeholder: 'Choose a color...',
- *   border: {
- *     type: 1,
- *     left: true,
- *     right: true,
- *     top: true,
- *     bottom: true,
- *   },
- * });
- *
- * // Listen for selection changes
- * onSelectChange(colorPicker, (value, label, index) => {
- *   console.log(`Selected: ${label} (${value})`);
- * });
- * ```
- */
-declare function createSelectEntity(world: World, config?: SelectConfig): Entity;
-/**
- * Creates a slider entity.
- *
- * Sliders allow users to select a value from a range using keyboard or mouse.
- *
- * @param world - The ECS world
- * @param config - Slider configuration
- * @returns Entity ID
- *
- * @example
- * ```typescript
- * import { createSliderEntity, onSliderChange } from 'blecsd';
- *
- * const slider = createSliderEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 30,
- *   min: 0,
- *   max: 100,
- *   value: 50,
- *   step: 5,
- *   showValue: true,
- * });
- *
- * onSliderChange(slider, (value) => {
- *   console.log('Volume:', value);
- * });
- * ```
- */
-declare function createSliderEntity(world: World, config?: SliderConfig): Entity;
-/**
- * Creates a form container entity.
- *
- * Forms manage field navigation and data collection.
- *
- * @param world - The ECS world
- * @param config - Form configuration
- * @returns Entity ID
- *
- * @example
- * ```typescript
- * import { createFormEntity, createTextboxEntity, onFormSubmit, registerFormField } from 'blecsd';
- *
- * const form = createFormEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 40,
- *   height: 10,
- *   keys: true,
- * });
- *
- * const username = createTextboxEntity(world, {
- *   parent: form,
- *   x: 1,
- *   y: 1,
- *   width: 30,
- * });
- *
- * // Register field with name for form data
- * registerFormField(world, form, username, 'username', '');
- *
- * onFormSubmit(form, (values) => {
- *   console.log('Username:', values.username);
- * });
- * ```
- */
-declare function createFormEntity(world: World, config?: FormConfig): Entity;
-/**
- * Creates a progress bar entity.
- *
- * Progress bars display a visual indicator of completion.
- *
- * @param world - The ECS world
- * @param config - Progress bar configuration
- * @returns Entity ID
- *
- * @example
- * ```typescript
- * import { createProgressBarEntity, setProgress, onProgressComplete } from 'blecsd';
- *
- * const progressBar = createProgressBarEntity(world, {
- *   x: 10,
- *   y: 5,
- *   width: 30,
- *   height: 1,
- *   value: 0,
- *   max: 100,
- * });
- *
- * onProgressComplete(progressBar, () => {
- *   console.log('Task complete!');
- * });
- *
- * // Update progress
- * setProgress(world, progressBar, 50);
- * ```
- */
-declare function createProgressBarEntity(world: World, config?: ProgressBarConfig): Entity;
-/**
- * Creates a radio set container entity.
- *
- * Radio sets manage mutual exclusion of radio buttons.
- *
- * @param world - The ECS world
- * @param config - Radio set configuration
- * @returns Entity ID
- *
- * @example
- * ```typescript
- * import { createRadioSetEntity, createRadioButtonEntity, onRadioSelect } from 'blecsd';
- *
- * const radioSet = createRadioSetEntity(world, {
- *   x: 10,
- *   y: 5,
- * });
- *
- * const opt1 = createRadioButtonEntity(world, {
- *   radioSet,
- *   value: 'option1',
- *   label: 'Option 1',
- *   selected: true,
- * });
- *
- * onRadioSelect(radioSet, (value) => {
- *   console.log('Selected:', value);
- * });
- * ```
- */
-declare function createRadioSetEntity(world: World, config?: RadioSetConfig): Entity;
-/**
- * Creates a radio button entity.
- *
- * Radio buttons provide exclusive selection within a radio set.
- *
- * @param world - The ECS world
- * @param config - Radio button configuration
- * @returns Entity ID
- *
- * @example
- * ```typescript
- * import { createRadioButtonEntity, selectRadioButton } from 'blecsd';
- *
- * const button = createRadioButtonEntity(world, {
- *   radioSet: radioSetEntity,
- *   value: 'choice1',
- *   label: 'First Choice',
- *   y: 0,
- * });
- *
- * // Select this button
- * selectRadioButton(world, button);
- * ```
- */
-declare function createRadioButtonEntity(world: World, config?: RadioButtonConfig): Entity;
 
 /**
  * Input event buffer for frame-independent input handling.
@@ -2499,11 +1788,11 @@ interface ActionBinding {
     /** Keys that activate this action */
     readonly keys: readonly string[];
     /** Mouse buttons that activate this action */
-    readonly mouseButtons?: readonly MouseButton[];
+    readonly mouseButtons?: readonly MouseButton[] | undefined;
     /** Whether action fires continuously while held (default: false) */
-    readonly continuous?: boolean;
+    readonly continuous?: boolean | undefined;
     /** Deadzone for analog inputs (0-1, default: 0.1) */
-    readonly deadzone?: number;
+    readonly deadzone?: number | undefined;
 }
 /**
  * Runtime state of an action.
@@ -2528,8 +1817,8 @@ interface SerializedBindings {
     readonly bindings: readonly {
         readonly action: string;
         readonly keys: readonly string[];
-        readonly mouseButtons?: readonly string[];
-        readonly continuous?: boolean;
+        readonly mouseButtons?: readonly string[] | undefined;
+        readonly continuous?: boolean | undefined;
     }[];
 }
 /**
@@ -2634,4 +1923,4 @@ declare const ActionPresets: {
     readonly menu: readonly ActionBinding[];
 };
 
-export { createCheckboxEntity as $, type ActionBinding as A, type BoxConfig as B, type CheckboxConfig as C, RadioSetConfigSchema as D, type ScreenConfig as E, type FormConfig as F, ScreenConfigSchema as G, SelectConfigSchema as H, type InputEventBufferData as I, type SerializedBindings as J, type KeyState as K, type ListConfig as L, type MouseButtonState as M, SerializedBindingsSchema as N, SliderConfigSchema as O, type ProgressBarConfig as P, TextConfigSchema as Q, type RadioButtonConfig as R, type SelectConfig as S, type TextConfig as T, TextareaConfigSchema as U, TextboxConfigSchema as V, type TimestampedInputEvent as W, type TimestampedKeyEvent as X, type TimestampedMouseEvent as Y, createBoxEntity as Z, createButtonEntity as _, type InputState as a, createFormEntity as a0, createInputActionManager as a1, createInputEntity as a2, createInputEventBuffer as a3, createInputState as a4, createListEntity as a5, createProgressBarEntity as a6, createRadioButtonEntity as a7, createRadioSetEntity as a8, createScreenEntity as a9, recordLatencyBatch as aA, resetLatencyStats as aB, resetStats as aC, beginFrame as aD, clearBuffer as aE, endFrame as aF, getStats as aG, createSelectEntity as aa, createSliderEntity as ab, createTextEntity as ac, createTextareaEntity as ad, createTextboxEntity as ae, drainAllEvents as af, drainKeys as ag, drainMouse as ah, getLatencyStats as ai, getMovementDirection as aj, getPendingCount as ak, getPendingKeyCount as al, getPendingMouseCount as am, globalInputBuffer as an, hasPendingEvents as ao, isAllKeysDown as ap, isAnyKeyDown as aq, isAnyKeyPressed as ar, isLatencyAcceptable as as, isProcessingTimeAcceptable as at, peekEvents as au, peekKeys as av, peekMouse as aw, pushKeyEvent as ax, pushMouseEvent as ay, recordLatency as az, type ButtonConfig as b, type InputConfig as c, type TextareaConfig as d, type TextboxConfig as e, type RadioSetConfig as f, type SliderConfig as g, ActionBindingSchema as h, type ActionCallback as i, ActionPresets as j, type ActionState as k, BoxConfigSchema as l, ButtonConfigSchema as m, CheckboxConfigSchema as n, FormConfigSchema as o, type InputActionManager as p, type InputBufferStats as q, InputConfigSchema as r, type InputEventBufferOptions as s, type InputLatencyStats as t, type InputStateConfig as u, type InputStateStats as v, ListConfigSchema as w, type MouseState as x, ProgressBarConfigSchema as y, RadioButtonConfigSchema as z };
+export { createInputEventBuffer as $, type ActionBinding as A, type BoxConfig as B, type CheckboxConfig as C, RadioSetConfigSchema as D, type ScreenConfig as E, type FormConfig as F, ScreenConfigSchema as G, SelectConfigSchema as H, type InputEventBufferData as I, type SerializedBindings as J, type KeyState as K, type ListConfig as L, type MouseButtonState as M, SerializedBindingsSchema as N, SliderConfigSchema as O, type ProgressBarConfig as P, TextConfigSchema as Q, type RadioButtonConfig as R, type SelectConfig as S, type TextConfig as T, TextareaConfigSchema as U, TextboxConfigSchema as V, type TimestampedInputEvent as W, type TimestampedKeyEvent as X, type TimestampedMouseEvent as Y, beginFrame as Z, createInputActionManager as _, type InputState as a, createInputState as a0, drainAllEvents as a1, drainKeys as a2, drainMouse as a3, endFrame as a4, getLatencyStats as a5, getMovementDirection as a6, getPendingCount as a7, getPendingKeyCount as a8, getPendingMouseCount as a9, globalInputBuffer as aa, hasPendingEvents as ab, isAllKeysDown as ac, isAnyKeyDown as ad, isAnyKeyPressed as ae, isLatencyAcceptable as af, isProcessingTimeAcceptable as ag, peekEvents as ah, peekKeys as ai, peekMouse as aj, pushKeyEvent as ak, pushMouseEvent as al, recordLatency as am, recordLatencyBatch as an, resetLatencyStats as ao, resetStats as ap, clearBuffer as aq, getStats as ar, type ButtonConfig as b, type InputConfig as c, type TextareaConfig as d, type TextboxConfig as e, type RadioSetConfig as f, type SliderConfig as g, ActionBindingSchema as h, type ActionCallback as i, ActionPresets as j, type ActionState as k, BoxConfigSchema as l, ButtonConfigSchema as m, CheckboxConfigSchema as n, FormConfigSchema as o, type InputActionManager as p, type InputBufferStats as q, InputConfigSchema as r, type InputEventBufferOptions as s, type InputLatencyStats as t, type InputStateConfig as u, type InputStateStats as v, ListConfigSchema as w, type MouseState as x, ProgressBarConfigSchema as y, RadioButtonConfigSchema as z };