@lombard.finance/sdk-devtools 0.1.0-canary-2.10

package/dist/index.d.ts

@@ -0,0 +1,830 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * SDK DevTools - Type Definitions
+ *
+ * Core types for the Lombard SDK DevTools package.
+ * These are framework-agnostic and can be used with any UI framework.
+ */
+/**
+ * Represents an event emitted by the SDK
+ */
+interface DevToolsEvent {
+    /** Unique event ID */
+    id: string;
+    /** Event type (e.g., 'status-change', 'error', 'completed') */
+    type: string;
+    /** Unix timestamp when event occurred */
+    timestamp: number;
+    /** Event payload data */
+    data: unknown;
+    /** Source action name (e.g., 'BtcStake', 'EvmUnstake') */
+    source?: string;
+    /** Whether this event came from the SDK's built-in event emitter */
+    isSDKEvent: boolean;
+}
+/**
+ * Log entry for reducer actions (Redux DevTools style)
+ */
+interface ReducerLogEntry {
+    /** Unique log ID */
+    id: string;
+    /** Unix timestamp when action was dispatched */
+    timestamp: number;
+    /** The dispatched action */
+    action: {
+        type: string;
+        payload?: unknown;
+    };
+    /** State before action */
+    prevState: unknown;
+    /** State after action */
+    nextState: unknown;
+}
+/**
+ * Minimal interface for monitorable SDK actions
+ * Matches the SDK's MonitorableAction interface
+ */
+interface MonitorableAction {
+    /** Current status of the action */
+    readonly status: string;
+    /** Whether an async operation is in progress */
+    readonly isLoading: boolean;
+    /** Error that occurred (if any) */
+    readonly error: Error | null;
+    /** Whether the action has failed */
+    readonly isFailed: boolean;
+    /** Subscribe to events */
+    on(event: string, handler: (...args: unknown[]) => void): () => void;
+}
+/**
+ * Registered action with metadata
+ */
+interface RegisteredAction {
+    /** Unique name for this action instance */
+    name: string;
+    /** The action instance */
+    action: MonitorableAction;
+    /** When the action was registered */
+    registeredAt: number;
+    /** Category (btc, evm, solana, etc.) */
+    category?: string;
+}
+/**
+ * Represents a step in an action flow
+ */
+interface FlowStep {
+    /** Step identifier */
+    id: string;
+    /** Display label */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Step status */
+    status: 'pending' | 'current' | 'completed' | 'error';
+}
+/**
+ * Position options for the floating widget
+ */
+type DevToolsPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+/**
+ * Theme options for DevTools
+ */
+type DevToolsTheme = 'dark' | 'light' | 'system';
+/**
+ * Configuration options for DevTools
+ */
+interface DevToolsConfig {
+    /** Widget position on screen */
+    position?: DevToolsPosition;
+    /** Whether to start open or collapsed */
+    defaultOpen?: boolean;
+    /** Theme preference */
+    theme?: DevToolsTheme;
+    /** Show environment indicator */
+    showEnvironment?: boolean;
+    /** Enable console logging alongside widget */
+    consoleLogging?: boolean;
+    /** Maximum number of events to retain */
+    maxEvents?: number;
+    /** Maximum number of reducer logs to retain */
+    maxReducerLogs?: number;
+}
+/**
+ * Default DevTools configuration
+ */
+declare const DEFAULT_DEVTOOLS_CONFIG: Required<DevToolsConfig>;
+/**
+ * Mock addresses for testing without real wallets
+ */
+interface MockAddresses {
+    evm: string;
+    bitcoin: string;
+    solana: string;
+    sui: string;
+    starknet: string;
+}
+/**
+ * Mock wallet state and controls
+ */
+interface MockWalletState {
+    /** Whether mock wallet is enabled */
+    isEnabled: boolean;
+    /** Current mock address (based on chain type) */
+    address: string;
+    /** Current mock chain ID */
+    chainId: number;
+    /** Whether mock wallet can sign (always false) */
+    canSign: boolean;
+    /** Enable mock wallet */
+    enable: () => void;
+    /** Disable mock wallet */
+    disable: () => void;
+    /** Toggle mock wallet */
+    toggle: () => void;
+    /** Set mock chain */
+    setChain: (chainId: number) => void;
+    /** Get mock address for a specific chain type */
+    getAddress: (chainType: keyof MockAddresses) => string;
+}
+/**
+ * Warning severity levels
+ */
+type WarningSeverity = 'info' | 'warning' | 'error';
+/**
+ * DevTools warning message
+ */
+interface DevToolsWarning {
+    /** Unique warning ID */
+    id: string;
+    /** Warning severity */
+    severity: WarningSeverity;
+    /** Warning title */
+    title: string;
+    /** Warning message */
+    message: string;
+    /** Link to documentation */
+    docsLink?: string;
+    /** Suggested code fix */
+    suggestedFix?: string;
+    /** When the warning was triggered */
+    timestamp: number;
+}
+/**
+ * HTTP method types
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+/**
+ * API request event - logged when a request is initiated
+ */
+interface ApiRequestEvent {
+    /** Unique request ID */
+    id: string;
+    /** Event type */
+    type: 'api-request';
+    /** HTTP method */
+    method: HttpMethod;
+    /** Request URL (full or relative) */
+    url: string;
+    /** Request payload (body or params) */
+    payload?: unknown;
+    /** Request headers (selected) */
+    headers?: Record<string, string>;
+    /** When the request was initiated */
+    timestamp: number;
+    /** Source/origin of the request (e.g., 'api.deposits', 'btc.stake') */
+    source?: string;
+}
+/**
+ * API response event - logged when a response is received
+ */
+interface ApiResponseEvent {
+    /** Unique response ID */
+    id: string;
+    /** Event type */
+    type: 'api-response';
+    /** Corresponding request ID */
+    requestId: string;
+    /** HTTP status code */
+    status: number;
+    /** Status text (e.g., 'OK', 'Not Found') */
+    statusText?: string;
+    /** Response data (parsed) */
+    data?: unknown;
+    /** Error message if request failed */
+    error?: string;
+    /** Request duration in milliseconds */
+    duration: number;
+    /** When the response was received */
+    timestamp: number;
+}
+/**
+ * Combined API event for the Network log
+ */
+interface NetworkLogEntry {
+    /** Request details */
+    request: ApiRequestEvent;
+    /** Response details (null if pending) */
+    response: ApiResponseEvent | null;
+    /** Whether the request is still pending */
+    isPending: boolean;
+    /** Whether the request failed */
+    isFailed: boolean;
+}
+
+/**
+ * DevToolsBridge - Connects SDK actions to DevTools automatically
+ *
+ * This is the core integration layer that makes DevTools "just work"
+ * with the Lombard SDK. It automatically subscribes to action events
+ * and provides the collected data to DevTools components.
+ *
+ * ## How It Works
+ *
+ * 1. Wrap the SDK at initialization
+ * 2. Automatically intercept action creation
+ * 3. Subscribe to all action events
+ * 4. Aggregate events/state for DevTools display
+ *
+ * @module sdk-devtools/bridge
+ */
+
+type DevToolsEventCallback = (event: DevToolsEvent) => void;
+type DevToolsStateCallback = (actions: Map<string, RegisteredAction>) => void;
+/**
+ * DevToolsBridge - Collects events from all SDK actions
+ *
+ * Usage:
+ * ```typescript
+ * // Create bridge
+ * const bridge = new DevToolsBridge();
+ *
+ * // Register an action
+ * const stake = sdk.btc.stake({ ... });
+ * bridge.registerAction('btc-stake', stake);
+ *
+ * // Subscribe to events
+ * const unsubscribe = bridge.onEvent((event) => {
+ *   console.log('SDK Event:', event);
+ * });
+ *
+ * // Get all events
+ * const events = bridge.getEvents();
+ *
+ * // Get registered actions
+ * const actions = bridge.getActions();
+ * ```
+ */
+declare class DevToolsBridge {
+    private events;
+    private actions;
+    private unsubscribers;
+    private eventListeners;
+    private stateListeners;
+    private config;
+    private eventIdCounter;
+    private networkLog;
+    private networkListeners;
+    private requestIdCounter;
+    constructor(config?: DevToolsConfig);
+    /**
+     * Register an SDK action for monitoring
+     *
+     * Automatically subscribes to all standard events:
+     * - status-change
+     * - error
+     * - completed
+     * - failed
+     * - loading
+     * - progress
+     */
+    registerAction(name: string, action: MonitorableAction, options?: {
+        category?: string;
+    }): () => void;
+    /**
+     * Unregister an action
+     */
+    unregisterAction(name: string): void;
+    private handleEvent;
+    private notifyEventListeners;
+    private notifyStateListeners;
+    /**
+     * Subscribe to new events
+     */
+    onEvent(callback: DevToolsEventCallback): () => void;
+    /**
+     * Subscribe to action state changes
+     */
+    onStateChange(callback: DevToolsStateCallback): () => void;
+    /**
+     * Get all collected events
+     */
+    getEvents(): DevToolsEvent[];
+    /**
+     * Get all registered actions
+     */
+    getActions(): Map<string, RegisteredAction>;
+    /**
+     * Get current state summary for all actions
+     */
+    getStateSummary(): Record<string, {
+        status: string;
+        isLoading: boolean;
+        hasError: boolean;
+    }>;
+    /**
+     * Log an API request
+     *
+     * Call this when an HTTP request is initiated.
+     * Returns a request ID to correlate with the response.
+     */
+    logApiRequest(params: {
+        method: HttpMethod;
+        url: string;
+        payload?: unknown;
+        headers?: Record<string, string>;
+        source?: string;
+    }): string;
+    /**
+     * Log an API response
+     *
+     * Call this when an HTTP response is received.
+     * Pass the requestId returned from logApiRequest.
+     */
+    logApiResponse(params: {
+        requestId: string;
+        status: number;
+        statusText?: string;
+        data?: unknown;
+        error?: string;
+    }): void;
+    /**
+     * Subscribe to network log changes
+     */
+    onNetworkChange(callback: (entries: NetworkLogEntry[]) => void): () => void;
+    /**
+     * Get all network log entries
+     */
+    getNetworkLog(): NetworkLogEntry[];
+    /**
+     * Clear network log
+     */
+    clearNetworkLog(): void;
+    private notifyNetworkListeners;
+    /**
+     * Clear all events
+     */
+    clearEvents(): void;
+    /**
+     * Clear all registered actions
+     */
+    clearActions(): void;
+    /**
+     * Destroy the bridge
+     */
+    destroy(): void;
+}
+/**
+ * Get or create the global DevTools bridge
+ */
+declare function getDevToolsBridge(config?: DevToolsConfig): DevToolsBridge;
+/**
+ * Reset the global DevTools bridge
+ */
+declare function resetDevToolsBridge(): void;
+
+interface DevToolsContextValue {
+    /** All collected events */
+    events: DevToolsEvent[];
+    /** All registered actions */
+    actions: Map<string, RegisteredAction>;
+    /** Network log entries (API requests/responses) */
+    networkLog: NetworkLogEntry[];
+    /** Register an action for monitoring */
+    registerAction: (name: string, action: MonitorableAction, options?: {
+        category?: string;
+    }) => () => void;
+    /** Unregister an action */
+    unregisterAction: (name: string) => void;
+    /** Clear all events */
+    clearEvents: () => void;
+    /** Clear network log */
+    clearNetworkLog: () => void;
+    /** Get current state of all actions */
+    getStateSummary: () => Record<string, {
+        status: string;
+        isLoading: boolean;
+        hasError: boolean;
+    }>;
+    /** The underlying bridge instance */
+    bridge: DevToolsBridge;
+    /** Whether DevTools is enabled */
+    isEnabled: boolean;
+}
+interface DevToolsProviderProps {
+    children: ReactNode;
+    /** DevTools configuration */
+    config?: DevToolsConfig;
+    /**
+     * Whether DevTools is enabled.
+     *
+     * Default: `process.env.NODE_ENV !== 'production'`
+     *
+     * For development/testing tools (like sdk-demo), you may want to always
+     * enable DevTools with `enabled={true}` regardless of environment, so
+     * developers can debug production SDK endpoints.
+     */
+    enabled?: boolean;
+}
+/**
+ * DevTools Provider
+ *
+ * Wrap your app with this provider to enable DevTools functionality.
+ *
+ * The `enabled` prop defaults to `false` in production (NODE_ENV === 'production')
+ * as a safety net. However, you can explicitly override this:
+ * - `enabled={true}` - Always enable (useful for dev tools testing prod SDK)
+ * - `enabled={false}` - Always disable
+ *
+ * @example
+ * ```tsx
+ * // Basic usage - auto-disabled in production builds
+ * function App() {
+ *   return (
+ *     <DevToolsProvider>
+ *       <MyApp />
+ *     </DevToolsProvider>
+ *   );
+ * }
+ *
+ * // Always enable (for developer tools/playgrounds)
+ * function DevToolApp() {
+ *   return (
+ *     <DevToolsProvider enabled={true}>
+ *       <MyApp />
+ *     </DevToolsProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function DevToolsProvider({ children, config, enabled, }: DevToolsProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access DevTools context
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { registerAction, events } = useDevToolsContext();
+ *
+ *   useEffect(() => {
+ *     const action = sdk.btc.stake({ ... });
+ *     return registerAction('stake', action);
+ *   }, []);
+ *
+ *   return <div>Events: {events.length}</div>;
+ * }
+ * ```
+ */
+declare function useDevToolsContext(): DevToolsContextValue;
+/**
+ * Hook to register an action with DevTools (from within context)
+ *
+ * @example
+ * ```tsx
+ * function StakeComponent() {
+ *   const stake = useMemo(() => sdk.btc.stake({ ... }), []);
+ *   useRegisterAction('stake', stake);
+ *
+ *   return <button onClick={() => stake.prepare({ ... })}>Stake</button>;
+ * }
+ * ```
+ */
+declare function useRegisterAction(name: string, action: MonitorableAction | null, category?: string): void;
+
+type TabId = 'events' | 'reducer' | 'state' | 'network';
+interface DevToolsPanelProps {
+    /** SDK events to display */
+    events: DevToolsEvent[];
+    /** Clear SDK events callback */
+    onClearEvents: () => void;
+    /** Reducer action logs */
+    reducerLogs?: ReducerLogEntry[];
+    /** Clear reducer logs callback */
+    onClearReducerLogs?: () => void;
+    /** Current state for inspection */
+    state?: Record<string, unknown>;
+    /** Network log entries */
+    networkLog?: NetworkLogEntry[];
+    /** Clear network log callback */
+    onClearNetworkLog?: () => void;
+    /** Initial tab to show */
+    initialTab?: TabId;
+    /** Whether to show minimized by default */
+    defaultMinimized?: boolean;
+    /** Custom class name */
+    className?: string;
+    /** Optional title */
+    title?: string;
+    /** Callback when minimize button is clicked (for external control) */
+    onMinimize?: () => void;
+}
+/**
+ * DevTools Panel Component
+ *
+ * Main container for all DevTools functionality with tabbed navigation.
+ */
+declare function DevToolsPanel({ events, onClearEvents, reducerLogs, onClearReducerLogs, state, networkLog, onClearNetworkLog, initialTab, defaultMinimized, className, title, onMinimize, }: DevToolsPanelProps): react_jsx_runtime.JSX.Element;
+
+interface EventLogProps {
+    /** Events to display */
+    events: DevToolsEvent[];
+    /** Callback to clear events */
+    onClear: () => void;
+    /** Optional title override */
+    title?: string;
+    /** Whether to show the info banner */
+    showInfoBanner?: boolean;
+    /** Custom class name for the container */
+    className?: string;
+}
+/**
+ * Event Log Component
+ *
+ * Console-style log showing SDK events with timestamps and color coding.
+ */
+declare function EventLog({ events, onClear, title, showInfoBanner, className, }: EventLogProps): react_jsx_runtime.JSX.Element;
+
+interface NetworkLogProps {
+    /** Network log entries */
+    entries: NetworkLogEntry[];
+    /** Clear network log callback */
+    onClear: () => void;
+    /** Maximum height for scrolling */
+    maxHeight?: string;
+}
+declare function NetworkLog({ entries, onClear, maxHeight, }: NetworkLogProps): react_jsx_runtime.JSX.Element;
+
+interface ReducerLogProps {
+    /** Log entries to display */
+    logs: ReducerLogEntry[];
+    /** Callback to clear logs */
+    onClear: () => void;
+    /** Custom class name */
+    className?: string;
+}
+/**
+ * Reducer Log Component
+ *
+ * Displays reducer actions in a time-ordered list with expandable details.
+ */
+declare function ReducerLog({ logs, onClear, className }: ReducerLogProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * StateInspector - Debug panel for inspecting state objects
+ *
+ * Displays state in an expandable JSON tree with syntax highlighting.
+ * Supports copy-to-clipboard and collapsible sections.
+ *
+ * @module sdk-devtools/components/StateInspector
+ */
+interface StateInspectorProps {
+    /** State object to inspect */
+    state: Record<string, unknown>;
+    /** Optional title */
+    title?: string;
+    /** Initial expansion depth (default: 2) */
+    defaultExpandDepth?: number;
+    /** Custom class name */
+    className?: string;
+}
+/**
+ * State Inspector Component
+ *
+ * Renders a collapsible JSON tree viewer with syntax highlighting.
+ */
+declare function StateInspector({ state, title, defaultExpandDepth, className, }: StateInspectorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * StatusBadge - Displays current flow status with color coding
+ *
+ * Shows the action status in a pill/badge format with appropriate colors.
+ *
+ * @module sdk-devtools/components/StatusBadge
+ */
+interface StatusBadgeProps {
+    /** Status string to display */
+    status?: string | unknown;
+    /** Custom class name */
+    className?: string;
+}
+/**
+ * Status Badge Component
+ *
+ * Displays action status with color coding based on status type.
+ */
+declare function StatusBadge({ status, className }: StatusBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Simple step definition (minimal required fields)
+ */
+interface SimpleStep {
+    id: string;
+    label: string;
+}
+interface StepIndicatorProps {
+    /** Steps to display - can be simple { id, label } or full FlowStep */
+    steps: SimpleStep[] | FlowStep[];
+    /** Current step index (0-based) */
+    currentStep: number;
+    /** Custom class name */
+    className?: string;
+}
+/**
+ * Step Indicator Component
+ *
+ * Horizontal progress indicator showing completed, current, and upcoming steps.
+ * Uses inline styles for sizing to avoid Tailwind v4 --spacing variable issues.
+ * Steps have equal widths to align with the progress bar above.
+ */
+declare function StepIndicator({ steps, currentStep, className, }: StepIndicatorProps): react_jsx_runtime.JSX.Element;
+/**
+ * Helper to convert simple step configs to FlowStep format
+ */
+declare function createSteps(configs: Array<{
+    id: string;
+    label: string;
+    description?: string;
+}>, currentStep: number): FlowStep[];
+
+/**
+ * useDevTools - React hook for integrating DevTools with SDK actions
+ *
+ * This is the main hook that developers will use to connect DevTools
+ * to their SDK usage. It provides:
+ * - Automatic event collection
+ * - Action registration
+ * - State for DevTools components
+ *
+ * @module sdk-devtools/hooks/useDevTools
+ */
+
+interface UseDevToolsReturn {
+    /** All collected events */
+    events: DevToolsEvent[];
+    /** All registered actions */
+    actions: Map<string, RegisteredAction>;
+    /** Current state summary */
+    stateSummary: Record<string, {
+        status: string;
+        isLoading: boolean;
+        hasError: boolean;
+    }>;
+    /** Register an action for monitoring */
+    registerAction: (name: string, action: MonitorableAction, options?: {
+        category?: string;
+    }) => () => void;
+    /** Unregister an action */
+    unregisterAction: (name: string) => void;
+    /** Clear all events */
+    clearEvents: () => void;
+    /** Clear all actions */
+    clearActions: () => void;
+    /** The underlying bridge instance */
+    bridge: DevToolsBridge;
+}
+/**
+ * React hook for DevTools integration
+ *
+ * @example Basic usage
+ * ```tsx
+ * function MyComponent() {
+ *   const { events, registerAction, clearEvents } = useDevTools();
+ *
+ *   useEffect(() => {
+ *     const stake = sdk.btc.stake({ destChain: Chain.ETHEREUM, assetOut: AssetId.LBTC });
+ *     const unregister = registerAction('stake', stake);
+ *
+ *     return unregister;
+ *   }, []);
+ *
+ *   return (
+ *     <DevToolsPanel
+ *       events={events}
+ *       onClearEvents={clearEvents}
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * @example With useAction helper
+ * ```tsx
+ * function MyComponent() {
+ *   const { registerAction } = useDevTools();
+ *
+ *   const stake = useAction(() => {
+ *     const action = sdk.btc.stake({ ... });
+ *     registerAction('stake', action);
+ *     return action;
+ *   }, []);
+ *
+ *   // stake is automatically monitored
+ * }
+ * ```
+ */
+declare function useDevTools(config?: DevToolsConfig): UseDevToolsReturn;
+/**
+ * Hook that creates an action and automatically registers it with DevTools
+ *
+ * @example
+ * ```tsx
+ * const stake = useMonitoredAction(
+ *   'btc-stake',
+ *   () => sdk.btc.stake({ destChain: Chain.ETHEREUM, assetOut: AssetId.LBTC }),
+ *   [sdk],
+ * );
+ * ```
+ */
+declare function useMonitoredAction<T extends MonitorableAction>(name: string, createAction: () => T, deps: React.DependencyList): T | null;
+/**
+ * Hook that subscribes to events from a specific action
+ *
+ * @example
+ * ```tsx
+ * const { events, status, isLoading, error } = useActionEvents(stakeAction);
+ * ```
+ */
+declare function useActionEvents(action: MonitorableAction | null): {
+    events: DevToolsEvent[];
+    status: string;
+    isLoading: boolean;
+    error: Error | null;
+    isFailed: boolean;
+    clearEvents: () => void;
+};
+
+/**
+ * useMockWallet - Simulated wallet for testing SDK flows
+ *
+ * Provides mock addresses for exploring SDK without connecting a real wallet.
+ *
+ * IMPORTANT LIMITATIONS:
+ * The mock wallet provides valid addresses for UI exploration and auto-filling
+ * recipient fields. However, it CANNOT perform actual wallet operations:
+ * - EIP-712 signature signing (fee authorization)
+ * - Transaction signing
+ * - Message signing
+ *
+ * For full flow testing, connect a real wallet.
+ *
+ * @module sdk-devtools/hooks/useMockWallet
+ */
+
+/**
+ * Deterministic mock addresses for consistent testing.
+ * Uses well-known addresses that are valid for each chain type.
+ */
+declare const MOCK_ADDRESSES: MockAddresses;
+/**
+ * Mock wallet limitations - clearly document what it can/cannot do
+ */
+declare const MOCK_WALLET_LIMITATIONS: {
+    /** Cannot sign transactions */
+    cannotSign: boolean;
+    /** Steps that work with mock wallet */
+    supportedSteps: readonly ["Create", "Prepare"];
+    /** Steps that require real wallet */
+    unsupportedSteps: readonly ["Authorize", "Sign", "Execute"];
+    /** User-friendly message */
+    message: string;
+    /** Short message for badges */
+    shortMessage: string;
+};
+/**
+ * Hook for managing mock wallet state
+ *
+ * Provides a mock wallet that auto-fills addresses but cannot sign transactions.
+ * State is persisted in localStorage.
+ *
+ * @example
+ * ```tsx
+ * const mockWallet = useMockWallet();
+ *
+ * if (!connectedWallet && !mockWallet.isEnabled) {
+ *   return <button onClick={mockWallet.enable}>Use Mock Wallet</button>;
+ * }
+ *
+ * const address = connectedWallet?.address ?? mockWallet.address;
+ * ```
+ */
+declare function useMockWallet(): MockWalletState;
+/**
+ * Get mock address for a chain type
+ */
+declare function getMockAddress(chainType: keyof MockAddresses): string;
+/**
+ * Check if a step requires a real wallet
+ */
+declare function requiresRealWallet(stepLabel: string): boolean;
+
+export { type ApiRequestEvent, type ApiResponseEvent, DEFAULT_DEVTOOLS_CONFIG, DevToolsBridge, type DevToolsConfig, type DevToolsEvent, type DevToolsEventCallback, DevToolsPanel, type DevToolsPanelProps, type DevToolsPosition, DevToolsProvider, type DevToolsProviderProps, type DevToolsStateCallback, type DevToolsTheme, type DevToolsWarning, EventLog, type EventLogProps, type FlowStep, type HttpMethod, MOCK_ADDRESSES, MOCK_WALLET_LIMITATIONS, type MockAddresses, type MockWalletState, type MonitorableAction, NetworkLog, type NetworkLogEntry, ReducerLog, type ReducerLogEntry, type ReducerLogProps, type RegisteredAction, StateInspector, type StateInspectorProps, StatusBadge, type StatusBadgeProps, StepIndicator, type StepIndicatorProps, type UseDevToolsReturn, type WarningSeverity, createSteps, getDevToolsBridge, getMockAddress, requiresRealWallet, resetDevToolsBridge, useActionEvents, useDevTools, useDevToolsContext, useMockWallet, useMonitoredAction, useRegisterAction };