@qontinui/ui-bridge 0.1.1

package/dist/react/index.d.ts

@@ -0,0 +1,786 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React$1, { ReactNode } from 'react';
+import { n as UIBridgeFeatures, U as UIBridgeConfig, t as WSConnectionState, l as RegisteredElement, R as RegisteredComponent, f as BridgeSnapshot, e as BridgeEventType, d as BridgeEventListener, X as WSSubscriptionOptions, c as BridgeEvent, i as ElementType, S as StandardAction, g as CustomAction, h as ElementState, E as ElementIdentifier, a1 as Workflow, p as UIStateGroup, o as UIState, m as StateSnapshot, a2 as WorkflowStep, T as TransitionResult, q as UITransition, N as NavigationResult, P as PathResult } from '../types-BpvpStn3.js';
+import { U as UIBridgeRegistry } from '../registry-D4mQ01B3.js';
+import { U as UIBridgeWSClient } from '../websocket-client-DupH0X7B.js';
+import { RenderLogManager } from '../render-log/index.js';
+import { M as MetricsCollector } from '../metrics-QCnK0EFw.js';
+import { A as ActionExecutor, i as WorkflowEngine, b as ControlActionRequest, c as ControlActionResponse, C as ComponentActionRequest, a as ComponentActionResponse, F as FindRequest, g as FindResponse, j as WorkflowRunRequest, k as WorkflowRunResponse } from '../types-BDkXy5si.js';
+
+/**
+ * UI Bridge context value
+ */
+interface UIBridgeContextValue {
+    /** Feature flags */
+    features: UIBridgeFeatures;
+    /** Configuration */
+    config: UIBridgeConfig;
+    /** Element registry */
+    registry: UIBridgeRegistry;
+    /** Action executor */
+    executor: ActionExecutor;
+    /** Workflow engine */
+    workflowEngine: WorkflowEngine;
+    /** Render log manager (if enabled) */
+    renderLog?: RenderLogManager;
+    /** Metrics collector (if debug enabled) */
+    metrics?: MetricsCollector;
+    /** WebSocket client (if websocket enabled) */
+    wsClient?: UIBridgeWSClient;
+    /** WebSocket connection state */
+    wsConnectionState: WSConnectionState;
+    /** Get all registered elements */
+    getElements: () => RegisteredElement[];
+    /** Get all registered components */
+    getComponents: () => RegisteredComponent[];
+    /** Create a snapshot */
+    createSnapshot: () => BridgeSnapshot;
+    /** Subscribe to events */
+    on: <T = unknown>(type: BridgeEventType, listener: BridgeEventListener<T>) => () => void;
+    /** Unsubscribe from events */
+    off: <T = unknown>(type: BridgeEventType, listener: BridgeEventListener<T>) => void;
+    /** Whether the provider is initialized */
+    initialized: boolean;
+    /** Connect to WebSocket server */
+    wsConnect: () => Promise<void>;
+    /** Disconnect from WebSocket server */
+    wsDisconnect: () => void;
+    /** Subscribe to WebSocket events */
+    wsSubscribe: (options: WSSubscriptionOptions) => Promise<BridgeEventType[]>;
+    /** Add WebSocket event listener */
+    onWsEvent: (eventType: BridgeEventType | '*', listener: (event: BridgeEvent) => void) => () => void;
+}
+/**
+ * UI Bridge provider props
+ */
+interface UIBridgeProviderProps {
+    /** Child components */
+    children: React$1.ReactNode;
+    /** Feature flags */
+    features?: UIBridgeFeatures;
+    /** Configuration */
+    config?: UIBridgeConfig;
+    /** Event handler */
+    onEvent?: BridgeEventListener;
+}
+/**
+ * UI Bridge Provider
+ *
+ * Provides UI Bridge context to child components.
+ */
+declare function UIBridgeProvider({ children, features, config, onEvent, }: UIBridgeProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * useUIBridgeContext hook
+ *
+ * Access the UI Bridge context. Throws if used outside provider.
+ */
+declare function useUIBridgeContext(): UIBridgeContextValue;
+/**
+ * useUIBridgeOptional hook
+ *
+ * Access the UI Bridge context, returning null if outside provider.
+ */
+declare function useUIBridgeOptional(): UIBridgeContextValue | null;
+
+/**
+ * useUIElement Hook
+ *
+ * Register a DOM element with UI Bridge for control and observation.
+ */
+
+/**
+ * useUIElement options
+ */
+interface UseUIElementOptions {
+    /** Unique identifier for the element */
+    id: string;
+    /** Element type (auto-detected if not provided) */
+    type?: ElementType;
+    /** Human-readable label */
+    label?: string;
+    /** Override available actions */
+    actions?: StandardAction[];
+    /** Custom actions */
+    customActions?: Record<string, CustomAction>;
+    /** Whether to automatically register on mount */
+    autoRegister?: boolean;
+    /** Callback when state changes */
+    onStateChange?: (state: ElementState) => void;
+}
+/**
+ * useUIElement return value
+ */
+interface UseUIElementReturn {
+    /** Ref to attach to the element */
+    ref: React.RefCallback<HTMLElement>;
+    /** Current element reference */
+    element: HTMLElement | null;
+    /** Whether the element is registered */
+    registered: boolean;
+    /** Get current state */
+    getState: () => ElementState | null;
+    /** Get element identifier */
+    getIdentifier: () => ElementIdentifier | null;
+    /** Trigger an action on this element */
+    trigger: (action: StandardAction | string, params?: Record<string, unknown>) => Promise<void>;
+    /** Manually register the element */
+    register: () => void;
+    /** Manually unregister the element */
+    unregister: () => void;
+    /** The registered element info */
+    registeredElement: RegisteredElement | null;
+}
+/**
+ * useUIElement hook
+ *
+ * Registers a DOM element with UI Bridge for programmatic control.
+ *
+ * @example
+ * ```tsx
+ * function SubmitButton() {
+ *   const { ref, trigger } = useUIElement({
+ *     id: 'submit-btn',
+ *     type: 'button',
+ *     label: 'Submit Form',
+ *   });
+ *
+ *   return (
+ *     <button ref={ref} data-ui-id="submit-btn">
+ *       Submit
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUIElement(options: UseUIElementOptions): UseUIElementReturn;
+/**
+ * useUIElementRef hook
+ *
+ * A simpler version that just adds the data-ui-id attribute.
+ * Useful when you only need identification without full registration.
+ */
+declare function useUIElementRef(id: string): React.RefCallback<HTMLElement>;
+
+/**
+ * useUIComponent Hook
+ *
+ * Register a component with UI Bridge for component-level actions.
+ */
+
+/**
+ * Action definition for useUIComponent
+ */
+interface ComponentActionDef<TParams = unknown, TResult = unknown> {
+    /** Action identifier */
+    id: string;
+    /** Human-readable label */
+    label?: string;
+    /** Description */
+    description?: string;
+    /** Handler function */
+    handler: (params?: TParams) => TResult | Promise<TResult>;
+}
+/**
+ * useUIComponent options
+ */
+interface UseUIComponentOptions {
+    /** Unique identifier for the component */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Actions available on this component */
+    actions?: ComponentActionDef[];
+    /** Child element IDs owned by this component */
+    elementIds?: string[];
+    /** Whether to automatically register on mount */
+    autoRegister?: boolean;
+}
+/**
+ * useUIComponent return value
+ */
+interface UseUIComponentReturn {
+    /** Whether the component is registered */
+    registered: boolean;
+    /** Execute an action on this component */
+    executeAction: <TParams = unknown, TResult = unknown>(actionId: string, params?: TParams) => Promise<TResult>;
+    /** Manually register the component */
+    register: () => void;
+    /** Manually unregister the component */
+    unregister: () => void;
+    /** Update actions dynamically */
+    updateActions: (actions: ComponentActionDef[]) => void;
+    /** Add an element ID to this component */
+    addElement: (elementId: string) => void;
+    /** Remove an element ID from this component */
+    removeElement: (elementId: string) => void;
+    /** The registered component info */
+    registeredComponent: RegisteredComponent | null;
+}
+/**
+ * useUIComponent hook
+ *
+ * Registers a component with UI Bridge for component-level control.
+ * Components can expose high-level actions that may orchestrate multiple element interactions.
+ *
+ * @example
+ * ```tsx
+ * function LoginForm() {
+ *   const [email, setEmail] = useState('');
+ *   const [password, setPassword] = useState('');
+ *
+ *   useUIComponent({
+ *     id: 'login-form',
+ *     name: 'Login Form',
+ *     actions: [
+ *       {
+ *         id: 'login',
+ *         label: 'Submit Login',
+ *         handler: async ({ email, password }) => {
+ *           setEmail(email);
+ *           setPassword(password);
+ *           await submitLogin();
+ *         },
+ *       },
+ *       {
+ *         id: 'clear',
+ *         label: 'Clear Form',
+ *         handler: () => {
+ *           setEmail('');
+ *           setPassword('');
+ *         },
+ *       },
+ *     ],
+ *   });
+ *
+ *   return (
+ *     <form>
+ *       <input value={email} onChange={(e) => setEmail(e.target.value)} />
+ *       <input value={password} onChange={(e) => setPassword(e.target.value)} />
+ *       <button type="submit">Login</button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */
+declare function useUIComponent(options: UseUIComponentOptions): UseUIComponentReturn;
+/**
+ * useUIComponentAction hook
+ *
+ * Create a stable action handler that can be used with useUIComponent.
+ * Useful for memoizing action handlers.
+ */
+declare function useUIComponentAction<TParams = unknown, TResult = unknown>(handler: (params?: TParams) => TResult | Promise<TResult>, deps: React.DependencyList): (params?: TParams) => TResult | Promise<TResult>;
+
+/**
+ * useUIBridge Hook
+ *
+ * Main hook for accessing UI Bridge functionality.
+ */
+
+/**
+ * useUIBridge return value
+ */
+interface UseUIBridgeReturn {
+    /** Whether UI Bridge is available */
+    available: boolean;
+    /** Whether initialized */
+    initialized: boolean;
+    /** Get all registered elements */
+    elements: RegisteredElement[];
+    /** Get all registered components */
+    components: RegisteredComponent[];
+    /** Get all workflows */
+    workflows: Workflow[];
+    /** Create a snapshot of the current state */
+    createSnapshot: () => BridgeSnapshot;
+    /** Execute an action on an element */
+    executeAction: (elementId: string, request: ControlActionRequest) => Promise<ControlActionResponse>;
+    /** Execute an action on a component */
+    executeComponentAction: (componentId: string, request: ComponentActionRequest) => Promise<ComponentActionResponse>;
+    /** Find controllable elements */
+    find: (options?: FindRequest) => Promise<FindResponse>;
+    /**
+     * Discover controllable elements
+     * @deprecated Use find() instead
+     */
+    discover: (options?: FindRequest) => Promise<FindResponse>;
+    /** Run a workflow */
+    runWorkflow: (workflowId: string, request?: WorkflowRunRequest) => Promise<WorkflowRunResponse>;
+    /** Get element by ID */
+    getElement: (id: string) => RegisteredElement | undefined;
+    /** Get component by ID */
+    getComponent: (id: string) => RegisteredComponent | undefined;
+    /** Get element state by ID */
+    getElementState: (id: string) => ElementState | undefined;
+    /** Register a workflow */
+    registerWorkflow: (workflow: Workflow) => void;
+    /** Unregister a workflow */
+    unregisterWorkflow: (id: string) => void;
+    /** Capture a render log snapshot (if enabled) */
+    captureRenderLog: () => Promise<void>;
+    /** Get render log entries (if enabled) */
+    getRenderLogEntries: () => Promise<unknown[]>;
+    /** Clear render log (if enabled) */
+    clearRenderLog: () => Promise<void>;
+    /** Get metrics (if debug enabled) */
+    getMetrics: () => unknown | undefined;
+    /** Get action history (if debug enabled) */
+    getActionHistory: () => unknown[] | undefined;
+}
+/**
+ * useUIBridge hook
+ *
+ * Main hook for accessing UI Bridge functionality.
+ * Use this to interact with registered elements, components, and workflows.
+ *
+ * @example
+ * ```tsx
+ * function AutomationController() {
+ *   const bridge = useUIBridge();
+ *
+ *   const handleSubmit = async () => {
+ *     // Execute element action
+ *     await bridge.executeAction('submit-btn', { action: 'click' });
+ *
+ *     // Or use component action
+ *     await bridge.executeComponentAction('login-form', {
+ *       action: 'login',
+ *       params: { email: 'user@example.com', password: 'secret' },
+ *     });
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleSubmit}>
+ *       Automate Login
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUIBridge(): UseUIBridgeReturn;
+/**
+ * useUIBridgeRequired hook
+ *
+ * Same as useUIBridge but throws if UI Bridge is not available.
+ */
+declare function useUIBridgeRequired(): UseUIBridgeReturn;
+
+/**
+ * useUIState Hook
+ *
+ * Register and manage UI states with UI Bridge.
+ */
+
+/**
+ * useUIState options
+ */
+interface UseUIStateOptions {
+    /** Unique identifier for the state */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Element IDs belonging to this state */
+    elements?: string[];
+    /** Function to detect if state is active */
+    activeWhen?: () => boolean;
+    /** If true, blocks other state activations (modal behavior) */
+    blocking?: boolean;
+    /** Specific state IDs this state blocks */
+    blocks?: string[];
+    /** State group membership */
+    group?: string;
+    /** Cost for pathfinding (default: 1.0) */
+    pathCost?: number;
+    /** Custom metadata */
+    metadata?: Record<string, unknown>;
+    /** Whether to automatically register on mount */
+    autoRegister?: boolean;
+    /** Initial active state */
+    initialActive?: boolean;
+}
+/**
+ * useUIState return value
+ */
+interface UseUIStateReturn {
+    /** Whether the state is registered */
+    registered: boolean;
+    /** Whether the state is currently active */
+    isActive: boolean;
+    /** Activate this state */
+    activate: () => boolean;
+    /** Deactivate this state */
+    deactivate: () => boolean;
+    /** Toggle active state */
+    toggle: () => boolean;
+    /** Get all currently active states */
+    activeStates: string[];
+    /** Manually register the state */
+    register: () => void;
+    /** Manually unregister the state */
+    unregister: () => void;
+    /** The registered state info */
+    state: UIState | undefined;
+}
+/**
+ * useUIState hook
+ *
+ * Registers a UI state with UI Bridge for state management.
+ *
+ * @example
+ * ```tsx
+ * function LoginModal() {
+ *   const { isActive, activate, deactivate } = useUIState({
+ *     id: 'login-modal',
+ *     name: 'Login Modal',
+ *     blocking: true,
+ *     elements: ['login-email', 'login-password', 'login-submit'],
+ *   });
+ *
+ *   if (!isActive) return null;
+ *
+ *   return (
+ *     <div className="modal">
+ *       <button onClick={deactivate}>Close</button>
+ *       ...
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useUIState(options: UseUIStateOptions): UseUIStateReturn;
+/**
+ * useUIStateGroup hook
+ *
+ * Register and manage a state group with UI Bridge.
+ *
+ * @example
+ * ```tsx
+ * function NavigationSection() {
+ *   const { activate, deactivate } = useUIStateGroup({
+ *     id: 'nav-group',
+ *     name: 'Navigation',
+ *     states: ['nav-home', 'nav-about', 'nav-contact'],
+ *   });
+ *
+ *   // Activating the group activates all its states
+ *   // Deactivating the group deactivates all its states
+ * }
+ * ```
+ */
+interface UseUIStateGroupOptions {
+    /** Unique identifier for the group */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** State IDs belonging to this group */
+    states: string[];
+    /** Whether to automatically register on mount */
+    autoRegister?: boolean;
+}
+interface UseUIStateGroupReturn {
+    /** Whether the group is registered */
+    registered: boolean;
+    /** Activate all states in this group */
+    activate: () => string[];
+    /** Deactivate all states in this group */
+    deactivate: () => string[];
+    /** Manually register the group */
+    register: () => void;
+    /** Manually unregister the group */
+    unregister: () => void;
+    /** The registered group info */
+    group: UIStateGroup | undefined;
+}
+declare function useUIStateGroup(options: UseUIStateGroupOptions): UseUIStateGroupReturn;
+/**
+ * useActiveStates hook
+ *
+ * Subscribe to active states changes.
+ */
+declare function useActiveStates(): string[];
+/**
+ * useStateSnapshot hook
+ *
+ * Get a snapshot of all state management data.
+ */
+declare function useStateSnapshot(): StateSnapshot | null;
+
+/**
+ * useUITransition Hook
+ *
+ * Register and execute UI state transitions with UI Bridge.
+ */
+
+/**
+ * useUITransition options
+ */
+interface UseUITransitionOptions {
+    /** Unique identifier for the transition */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Precondition: at least one must be active */
+    fromStates: string[];
+    /** States to activate */
+    activateStates: string[];
+    /** States to deactivate */
+    exitStates: string[];
+    /** Groups to activate */
+    activateGroups?: string[];
+    /** Groups to deactivate */
+    exitGroups?: string[];
+    /** Actions to execute during transition */
+    actions?: WorkflowStep[];
+    /** Cost for pathfinding */
+    pathCost?: number;
+    /** Whether source states remain visible during transition */
+    staysVisible?: boolean;
+    /** Whether to automatically register on mount */
+    autoRegister?: boolean;
+}
+/**
+ * useUITransition return value
+ */
+interface UseUITransitionReturn {
+    /** Whether the transition is registered */
+    registered: boolean;
+    /** Whether this transition can be executed from current state */
+    canExecute: boolean;
+    /** Execute the transition */
+    execute: () => Promise<TransitionResult>;
+    /** Manually register the transition */
+    register: () => void;
+    /** Manually unregister the transition */
+    unregister: () => void;
+    /** The registered transition info */
+    transition: UITransition | undefined;
+}
+/**
+ * useUITransition hook
+ *
+ * Registers a state transition with UI Bridge.
+ *
+ * @example
+ * ```tsx
+ * function OpenModalButton() {
+ *   const { canExecute, execute } = useUITransition({
+ *     id: 'open-login-modal',
+ *     name: 'Open Login Modal',
+ *     fromStates: ['dashboard'],
+ *     activateStates: ['login-modal'],
+ *     exitStates: [],
+ *   });
+ *
+ *   return (
+ *     <button onClick={execute} disabled={!canExecute}>
+ *       Login
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUITransition(options: UseUITransitionOptions): UseUITransitionReturn;
+/**
+ * useTransitions hook
+ *
+ * Get all registered transitions.
+ */
+declare function useTransitions(): UITransition[];
+/**
+ * useAvailableTransitions hook
+ *
+ * Get transitions that can be executed from current state.
+ */
+declare function useAvailableTransitions(): UITransition[];
+
+/**
+ * useUINavigation Hook
+ *
+ * Navigate between UI states using pathfinding with UI Bridge.
+ */
+
+/**
+ * useUINavigation return value
+ */
+interface UseUINavigationReturn {
+    /** Whether UI Bridge is available */
+    available: boolean;
+    /** Whether navigation is currently in progress */
+    isNavigating: boolean;
+    /** Last navigation result */
+    lastResult: NavigationResult | null;
+    /** Find a path to target states (without executing) */
+    findPath: (targetStates: string[]) => PathResult;
+    /** Navigate to target states */
+    navigateTo: (targetStates: string[]) => Promise<NavigationResult>;
+    /** Current active states */
+    activeStates: string[];
+}
+/**
+ * useUINavigation hook
+ *
+ * Provides state machine navigation capabilities with pathfinding.
+ *
+ * @example
+ * ```tsx
+ * function NavigationController() {
+ *   const { navigateTo, findPath, isNavigating, activeStates } = useUINavigation();
+ *
+ *   const goToDashboard = async () => {
+ *     // Find path first to check if navigation is possible
+ *     const path = findPath(['dashboard']);
+ *     if (!path.found) {
+ *       console.log('Cannot reach dashboard from current state');
+ *       return;
+ *     }
+ *
+ *     console.log(`Will execute ${path.transitions.length} transitions`);
+ *
+ *     // Execute navigation
+ *     const result = await navigateTo(['dashboard']);
+ *     if (result.success) {
+ *       console.log('Successfully navigated to dashboard');
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Current states: {activeStates.join(', ')}</p>
+ *       <button onClick={goToDashboard} disabled={isNavigating}>
+ *         Go to Dashboard
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useUINavigation(): UseUINavigationReturn;
+/**
+ * useCanNavigateTo hook
+ *
+ * Check if navigation to target states is possible.
+ *
+ * @example
+ * ```tsx
+ * function DashboardLink() {
+ *   const canNavigate = useCanNavigateTo(['dashboard']);
+ *
+ *   return (
+ *     <button disabled={!canNavigate}>
+ *       Dashboard
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCanNavigateTo(targetStates: string[]): boolean;
+/**
+ * useNavigationPath hook
+ *
+ * Get the path to target states (updates when active states change).
+ *
+ * @example
+ * ```tsx
+ * function PathDisplay() {
+ *   const path = useNavigationPath(['checkout']);
+ *
+ *   if (!path.found) {
+ *     return <p>Cannot reach checkout from here</p>;
+ *   }
+ *
+ *   return (
+ *     <p>
+ *       Steps to checkout: {path.transitions.join(' -> ')}
+ *       (Cost: {path.totalCost})
+ *     </p>
+ *   );
+ * }
+ * ```
+ */
+declare function useNavigationPath(targetStates: string[]): PathResult;
+
+/**
+ * useAutoRegister Hook
+ *
+ * Enables automatic registration of interactive DOM elements with the UI Bridge.
+ * This eliminates the need for manual useUIElement() calls on every component.
+ *
+ * Features:
+ * - Auto-discovers interactive elements (buttons, inputs, links, etc.)
+ * - Uses MutationObserver to detect new elements
+ * - Smart ID generation (data-testid > data-ui-id > semantic > auto-generated)
+ * - Debounced updates for performance
+ * - Respects existing manually registered elements
+ */
+/**
+ * ID generation strategy
+ */
+type IdStrategy = 'data-testid' | 'data-ui-id' | 'semantic' | 'auto' | 'prefer-existing';
+/**
+ * Options for auto-registration
+ */
+interface AutoRegisterOptions {
+    /** Enable auto-registration (default: true in dev mode) */
+    enabled?: boolean;
+    /** Root element to observe (default: document.body) */
+    root?: HTMLElement | null;
+    /** ID generation strategy (default: 'prefer-existing') */
+    idStrategy?: IdStrategy;
+    /** Debounce time for mutation handling (ms, default: 100) */
+    debounceMs?: number;
+    /** Include hidden elements (default: false) */
+    includeHidden?: boolean;
+    /** Only register elements matching these selectors */
+    includeSelectors?: string[];
+    /** Exclude elements matching these selectors */
+    excludeSelectors?: string[];
+    /** Custom ID generator function */
+    generateId?: (element: HTMLElement) => string;
+    /** Callback when element is registered */
+    onRegister?: (id: string, element: HTMLElement) => void;
+    /** Callback when element is unregistered */
+    onUnregister?: (id: string) => void;
+}
+/**
+ * Hook for automatic element registration
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   // Enable auto-registration for all interactive elements
+ *   useAutoRegister({ enabled: true });
+ *
+ *   return (
+ *     <div>
+ *       <button data-testid="submit-btn">Submit</button>
+ *       <input data-testid="email-input" />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAutoRegister(options?: AutoRegisterOptions): void;
+
+interface AutoRegisterProviderProps extends Omit<AutoRegisterOptions, 'root'> {
+    /** Children to render */
+    children: ReactNode;
+    /** Use this element as the observation root instead of document.body */
+    scopeToChildren?: boolean;
+}
+/**
+ * Provider component that enables automatic element registration.
+ *
+ * Features:
+ * - Automatically discovers and registers interactive elements
+ * - Uses MutationObserver to detect new elements
+ * - Smart ID generation based on data-testid, semantic names, etc.
+ * - Configurable selectors and ID strategies
+ *
+ * Place this component at the root of your app (inside UIBridgeProvider)
+ * for comprehensive automatic element registration.
+ */
+declare function AutoRegisterProvider({ children, scopeToChildren, enabled, idStrategy, debounceMs, includeHidden, includeSelectors, excludeSelectors, generateId, onRegister, onUnregister, }: AutoRegisterProviderProps): react_jsx_runtime.JSX.Element;
+
+export { type AutoRegisterOptions, AutoRegisterProvider, type AutoRegisterProviderProps, type ComponentActionDef, type IdStrategy, type UIBridgeContextValue, UIBridgeProvider, type UIBridgeProviderProps, type UseUIBridgeReturn, type UseUIComponentOptions, type UseUIComponentReturn, type UseUIElementOptions, type UseUIElementReturn, type UseUINavigationReturn, type UseUIStateGroupOptions, type UseUIStateGroupReturn, type UseUIStateOptions, type UseUIStateReturn, type UseUITransitionOptions, type UseUITransitionReturn, useActiveStates, useAutoRegister, useAvailableTransitions, useCanNavigateTo, useNavigationPath, useStateSnapshot, useTransitions, useUIBridge, useUIBridgeContext, useUIBridgeOptional, useUIBridgeRequired, useUIComponent, useUIComponentAction, useUIElement, useUIElementRef, useUINavigation, useUIState, useUIStateGroup, useUITransition };