@appilots/sdk 0.2.0

package/dist/index.d.mts

@@ -0,0 +1,1156 @@
+import { P as PartialThemeTokens, A as AppilotsThemeTokens, a as AppilotsLocale, b as AgentAction, C as ComponentRegistry, c as AgentPermissions, d as AppilotsTraceEntry, F as FieldEntry, e as AppilotsEvent } from './index-BDb1WVNo.mjs';
+export { f as AgentActionType, g as AgentMessage, h as AppilotsClient, i as AppilotsClientOptions, j as AppilotsConfig, k as AppilotsEventHandler, l as AppilotsEventType, m as AppilotsI18nProvider, n as AppilotsI18nProviderProps, o as AppilotsProvider, p as AppilotsProviderProps, q as AppilotsStringKey, r as AppilotsStrings, s as AppilotsUser, t as ChatMessage, u as ComponentEntry, v as ComponentKind, E as EscalationState, w as FormFillPayload, M as MessageRole, N as NavigationPayload, R as RemotePersonalization, S as SliderEntry, x as SuggestedPrompt, T as TargetEntry, y as ToggleEntry, U as UIInteractionPayload, z as UseAppilotsFieldOptions, B as UseAppilotsSliderOptions, D as UseAppilotsTargetOptions, G as UseAppilotsToggleOptions, H as UseSuggestedPromptsOptions, I as UseSuggestedPromptsReturn, J as componentRegistry, K as createComponentRegistry, L as defaultDarkTheme, O as defaultLightTheme, Q as detectDeviceLocale, V as mergeThemeTokens, W as resolveLocale, X as useAppilots, Y as useAppilotsActions, Z as useAppilotsChat, _ as useAppilotsContext, $ as useAppilotsField, a0 as useAppilotsI18n, a1 as useAppilotsNavigation, a2 as useAppilotsSlider, a3 as useAppilotsTarget, a4 as useAppilotsToggle, a5 as useSuggestedPrompts } from './index-BDb1WVNo.mjs';
+import * as React$1 from 'react';
+import React__default from 'react';
+export { A as AppilotsNavigationContainer, N as NavigationConfig, b as ScreenMetadata, r as registerScreen } from './registerScreen-D1oGm28T.mjs';
+
+interface AppilotsThemeProviderProps {
+    /**
+     * Partial token overrides — merged on top of the resolved base
+     * (default light or dark). Accepts the same shape as the dashboard
+     * `theme` JSON, so configs round-trip without translation.
+     */
+    theme?: PartialThemeTokens | null;
+    /**
+     * `auto` (default) — follow `useColorScheme()` from React Native.
+     *  `light` / `dark` — force the theme regardless of device setting.
+     *  Useful when the host app is itself locked to one mode.
+     */
+    mode?: 'auto' | 'light' | 'dark';
+    children: React__default.ReactNode;
+}
+declare function AppilotsThemeProvider({ theme, mode, children, }: AppilotsThemeProviderProps): React__default.JSX.Element;
+/**
+ * Read the resolved theme tokens from context. Components MUST use this
+ * hook (or accept an explicit `theme` prop forwarded from a parent that
+ * called it) instead of importing `defaultLightTheme` directly — that
+ * import would defeat the dev's overrides.
+ */
+declare function useAppilotsTheme(): AppilotsThemeTokens;
+
+/**
+ * Tailwind → Appilots theme bridge (BACKLOG 4.1).
+ *
+ * Purpose: a developer who already has a Tailwind config in their app
+ * shouldn't have to manually copy hex codes into the Appilots `theme`
+ * prop. They can pass their resolved Tailwind config and we'll
+ * extract the closest-named tokens.
+ *
+ * This is intentionally fuzzy: Tailwind's color tree is `{primary:
+ * {500: "#..."}}` shaped while ours is flat. We pick the 500 shade for
+ * a named color (Tailwind's de-facto "default" shade) and fall back to
+ * the closest available shade if 500 is missing. Anything we can't
+ * confidently map is left out, so the SDK falls back to its bundled
+ * defaults for that token.
+ *
+ * Not a runtime dependency on tailwindcss — the developer passes the
+ * resolved config object in. (`require('tailwindcss/resolveConfig')`
+ * runs in the dev's app, not here, so this package stays Metro-safe.)
+ */
+
+/**
+ * Loose shape of a resolved Tailwind config. We only read what we
+ * need; the rest of the keys (variants, plugins, content) are ignored.
+ */
+interface TailwindResolvedConfig {
+    theme?: {
+        colors?: Record<string, string | Record<string, string>>;
+        fontFamily?: Record<string, string | string[]>;
+        fontSize?: Record<string, string | [string, string | {
+            lineHeight?: string;
+        }]>;
+        borderRadius?: Record<string, string>;
+    };
+}
+/**
+ * Build a `PartialThemeTokens` from a (resolved) Tailwind config.
+ *
+ * Only fields the dev clearly defined make it across — everything else
+ * stays unset so the Appilots defaults take over. This is "best effort":
+ * unmapped tokens are NOT an error.
+ */
+declare function appilotsThemeFromTailwind(config: TailwindResolvedConfig): PartialThemeTokens;
+/**
+ * Convenience namespace so dashboard docs can show `appilotsTheme.fromTailwind(...)`
+ * exactly as the backlog spec writes it.
+ */
+declare const appilotsTheme: {
+    fromTailwind: typeof appilotsThemeFromTailwind;
+};
+
+/**
+ * Layout modes for the chat (BACKLOG 4.1).
+ *  - `bubble`     — floating action button + bottom sheet modal (default)
+ *  - `fullscreen` — full-screen modal, no FAB
+ *  - `sidebar`    — half-width modal pinned to one side (tablet/web RN)
+ *  - `inline`     — render inline where it's mounted, no modal at all
+ */
+type AppilotsChatMode = 'bubble' | 'fullscreen' | 'sidebar' | 'inline';
+type AppilotsChatPosition = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+interface AppilotsChatProps {
+    /** Controlled visibility — when set, the FAB is hidden. */
+    visible?: boolean;
+    onClose?: () => void;
+    /** Override the input placeholder text. Falls back to the i18n bundle. */
+    placeholder?: string;
+    /** Override the chat header title. Falls back to assistantName, then i18n bundle. */
+    headerTitle?: string;
+    /** @deprecated Action traces are debug-only; confirmation prompts remain visible. */
+    showActionPreviews?: boolean;
+    /**
+     * Auto-execute non-confirm actions without user approval.
+     * @default true
+     */
+    autoExecute?: boolean;
+    /**
+     * Partial token overrides — merged on top of the resolved
+     * default-light or default-dark theme. See `@appilots/sdk/theme`.
+     *
+     * Backwards-compatible: the legacy {primaryColor, backgroundColor,
+     * textColor, inputBackgroundColor, borderRadius, fontFamily} shape
+     * still works, transparently mapped onto the new tokens.
+     */
+    theme?: PartialThemeTokens | LegacyThemeShape;
+    /** `auto` (default) follows the device color scheme; `light`/`dark` force. */
+    themeMode?: 'auto' | 'light' | 'dark';
+    /** Display name for the agent (overrides headerTitle's i18n fallback). */
+    assistantName?: string;
+    /** URL or local require()-able image for the avatar shown next to the title. */
+    assistantAvatar?: string | number | React__default.ReactNode;
+    /**
+     * Icon shown in the empty-state badge — an emoji/string (rendered
+     * literally inside the tinted circle) or an image (URL string starting
+     * with `http(s)://`, or a local `require()`-d asset, rendered without
+     * the tint). Falls back to the default `ChatIcon` bubble glyph.
+     */
+    emptyStateIcon?: string | number;
+    /** Optional hint shown under the empty-state title (replaces the default subtitle). */
+    welcomeMessage?: string;
+    /** Show the "Powered by Appilots" footer line. Defaults to true. */
+    poweredByVisible?: boolean;
+    mode?: AppilotsChatMode;
+    /** Only honoured when mode='bubble'. Positions the floating button. */
+    position?: AppilotsChatPosition;
+    /** Fully replace the floating button. `'none'` hides it entirely. */
+    triggerButton?: React__default.ReactNode | 'default' | 'none';
+    /**
+     * Replace ONLY the icon rendered inside the default FAB, keeping the
+     * default shape/size/background. Use this for a custom SVG without
+     * having to rebuild the entire button. Ignored when `triggerButton`
+     * is set to a ReactNode (the whole button is replaced anyway).
+     * Takes priority over `triggerButtonImage` when both are set.
+     */
+    triggerIcon?: React__default.ReactNode;
+    /**
+     * Background color of the default FAB. Falls back to
+     * `theme.colors.primary` when unset — same as the SDK's behavior
+     * before this prop existed.
+     */
+    triggerButtonColor?: string;
+    /**
+     * Image (URL or local `require()`-d asset) rendered inside the
+     * default FAB instead of the built-in chat-bubble icon — e.g. a
+     * company logo. Rendered with `resizeMode="contain"` and no forced
+     * tint (unlike the default icon, which is intentionally white).
+     * Ignored when `triggerIcon` is set.
+     */
+    triggerButtonImage?: string | number;
+    /** Force a locale. Falls through to device detection when omitted. */
+    locale?: AppilotsLocale;
+}
+/**
+ * Legacy theme shape used by the SDK before BACKLOG 4.1. Kept as an
+ * accepted union variant of the `theme` prop so existing apps don't
+ * need to change a single line.
+ */
+interface LegacyThemeShape {
+    primaryColor?: string;
+    backgroundColor?: string;
+    textColor?: string;
+    inputBackgroundColor?: string;
+    borderRadius?: number;
+    fontFamily?: string;
+}
+/**
+ * Outer wrapper — sets up Theme + i18n providers so the inner component
+ * (and the ConfirmDialog) all read from the same resolved tokens. This
+ * lets a developer mount AppilotsChat without also wrapping their app
+ * in a `<AppilotsThemeProvider>` manually.
+ */
+declare function AppilotsChat(props: AppilotsChatProps): React__default.JSX.Element;
+/**
+ * Re-exports kept for backwards compatibility — the legacy
+ * `AppilotsChatTheme` type used to live on this module. Prefer
+ * `import { type AppilotsThemeTokens } from '@appilots/sdk/theme'`.
+ */
+type AppilotsChatTheme = LegacyThemeShape;
+
+/**
+ * @deprecated Inline confirm cards (rendered by ActionBreadcrumb) have
+ * replaced the modal/overlay confirmation flow. This component is kept
+ * as an empty export only so existing import sites compile while
+ * consumers migrate.
+ *
+ * Why it went away:
+ *   - The original `<Modal>` flavor couldn't open on iOS while
+ *     AppilotsChat itself was in a Modal (RN refuses two concurrent
+ *     modals; the dialog silently never appeared).
+ *   - The user's choice (confirm / cancel) had no permanent surface
+ *     in the chat — the modal dismissed and the breadcrumb only
+ *     showed a transient "Aguardando confirmação..." badge.
+ *
+ * The replacement is the `ConfirmCard` rendered inside
+ * `ActionBreadcrumb` when an action of type `confirm` is in `pending`
+ * state. Approve/reject route through the standard
+ * `useAppilotsActions.approveAction(id)` / `rejectAction(id)`. Once
+ * resolved, the row stays in the chat as a permanent record
+ * ("Você confirmou" / "Você cancelou").
+ *
+ * To customise the inline card visually, theme it via the same
+ * `primaryColor` / `colors` props that `AppilotsChat` already accepts
+ * — the card inherits from those.
+ */
+
+interface ConfirmDialogProps {
+    primaryColor?: string;
+    destructiveColor?: string;
+}
+/** @deprecated No-op. See file header. */
+declare function ConfirmDialog(_props?: ConfirmDialogProps): React__default.ReactElement | null;
+
+/**
+ * Human-readable labels and error messages for the action breadcrumb.
+ *
+ * Strings are PT-BR hardcoded for now. i18n is planned for backlog item
+ * 4.1 (Personalização) — when that lands, these strings move into the
+ * locale bundles.
+ *
+ * Two responsibilities:
+ *   1. `describeAction(action)` — turns a typed AgentAction into a label
+ *      that varies by lifecycle state (pending/running/done/failed).
+ *   2. `humanizeError(raw, action)` — sanitises the raw error string from
+ *      the executor into a short user-facing reason. Stack traces and
+ *      protocol errors are collapsed into "algo deu errado" so users
+ *      aren't shown technical noise.
+ */
+
+type BreadcrumbState = 'pending' | 'running' | 'success' | 'failed';
+interface BreadcrumbItem {
+    /** What to render on the line. */
+    label: string;
+    /** Lifecycle state — drives icon + colour in the breadcrumb. */
+    state: BreadcrumbState;
+}
+/**
+ * Map an AgentAction + its current status to a breadcrumb item ready to
+ * render. The function is intentionally defensive — both the native-tools
+ * and JSON-fallback code paths feed actions through here, and the JSON
+ * path is loose with payload shapes, so every field access has to assume
+ * `unknown`.
+ */
+declare function describeAction(action: AgentAction): BreadcrumbItem;
+/**
+ * Convert the executor's raw error string into a short, user-facing
+ * reason that fits inside parentheses on the breadcrumb line. Returns
+ * `undefined` when there's no useful information to show — caller can
+ * then drop the parenthetical entirely.
+ *
+ * Heuristics:
+ *   - Apply known-pattern rewrites (rejected, not found, network, etc.)
+ *   - If the result looks technical (stack frame, HTTP status, JSON
+ *     dump) or is suspiciously long, fall back to "algo deu errado".
+ *   - Trim and lowercase the first letter so it reads naturally inside
+ *     the parens after the action verb.
+ */
+declare function humanizeError(raw: string | undefined, _action?: AgentAction): string | undefined;
+
+/**
+ * Pure presentation logic for ActionBreadcrumb, extracted from the RN
+ * component (same pattern as `humanizeAction.ts` / `chatTimeline.ts`)
+ * so it can be unit tested without a renderer:
+ *   - lifecycle state → tone (colors) and icon glyph;
+ *   - destructive detection (payload flag or action-level flag);
+ *   - confirm-card copy + colors derivation (title / message / button
+ *     labels / accent color / surface / border) with the
+ *     destructive-aware defaults.
+ *
+ * BACKLOG 4.2 — theming: this module used to hardcode every color
+ * (`#FFFFFF` card background, `#DC2626` destructive red, etc.), which is
+ * why the theme's `secondary`/`success`/`warning`/`error` tokens had no
+ * effect on the chat at all — nothing consumed them. Every color now
+ * comes from a `BreadcrumbPalette` the caller passes in (ultimately
+ * `useAppilotsTheme()` in AppilotsChat). `DEFAULT_BREADCRUMB_PALETTE` is
+ * built from the SDK's bundled `defaultLightTheme`, and `tokens.ts` picks
+ * its `success`/`warning`/`error` defaults to exactly reproduce the OLD
+ * hardcoded hex values below — so a caller on the default theme renders
+ * pixel-identical to before.
+ */
+
+/**
+ * The subset of theme tokens the breadcrumb (rows + confirm card)
+ * actually renders with. Every field is required here — callers (i.e.
+ * `ActionBreadcrumb`) fill gaps from `DEFAULT_BREADCRUMB_PALETTE` before
+ * calling into this module, so the pure functions never have to guess.
+ */
+interface BreadcrumbPalette {
+    /** Running-state tone + spinner/circle tint. Same value as `primaryColor`. */
+    primary: string;
+    /** High-contrast text — confirm-card title (non-destructive), row labels. */
+    text: string;
+    /** Muted text — confirm-card body copy, cancel button label. */
+    textSecondary: string;
+    /** Confirm-card background. */
+    surface: string;
+    /** Confirm-card border (non-destructive) and the cancel button fill. */
+    border: string;
+    /** "completed" tone. */
+    success: string;
+    /** "pending" (queued, not-yet-run) tone. See the token doc in `theme/tokens.ts`. */
+    warning: string;
+    /** "failed" tone AND every destructive badge/CTA (confirm card, reject button). */
+    error: string;
+}
+
+/**
+ * ActionBreadcrumb — compact, line-per-action progress UI.
+ *
+ * Replaces the per-action "card" UI with something closer to a CI build
+ * log: each action is one line, stamped with an icon that reflects its
+ * lifecycle state. Spinners on running actions, checks on success, ✗
+ * on failure. Failures show a humanised reason in parens.
+ *
+ * Why a separate component (instead of leaving render code inline in
+ * AppilotsChat.tsx): the lifecycle state animation is non-trivial and
+ * the same UI is now also rendered in three places (Mailing the spec
+ * — empty state, between message bubbles, and inline footer). Keeping
+ * it in one file makes the styling consistent.
+ *
+ * The component does NOT decide approve/reject visibility on its own —
+ * the caller passes `requireApprovalFor(action)` so this component stays
+ * presentational and the policy lives where the rest of the auto-execute
+ * config does (AppilotsChat).
+ */
+
+interface ActionBreadcrumbProps {
+    /** Actions to render, ordered by emission. Caller dedupes / groups. */
+    actions: AgentAction[];
+    /** Theme tokens — only the few colours the breadcrumb actually uses. */
+    primaryColor: string;
+    textColor: string;
+    fontFamily: string;
+    /**
+     * Extra theme tokens used for lifecycle tones (pending/success/failed)
+     * and the confirm-card surface/border/destructive accents. Optional —
+     * unset fields fall back to the SDK's bundled light theme, so callers
+     * that only ever passed `primaryColor`/`textColor`/`fontFamily` (the
+     * pre-4.2 shape of this prop set) keep rendering exactly as before.
+     */
+    palette?: Partial<Omit<BreadcrumbPalette, 'primary' | 'text'>>;
+    /**
+     * Approve/reject inline buttons appear when this returns true for an
+     * action in `pending` state. `confirm`-type actions are normally
+     * handled by ConfirmDialog (modal), so callers pass false for those.
+     */
+    requireApprovalFor?: (action: AgentAction) => boolean;
+    /** Required when `requireApprovalFor` returns true for any action. */
+    onApprove?: (actionId: string) => void;
+    onReject?: (actionId: string) => void;
+}
+declare function ActionBreadcrumb({ actions, primaryColor, textColor, fontFamily, palette, requireApprovalFor, onApprove, onReject, }: ActionBreadcrumbProps): React__default.JSX.Element | null;
+
+interface ChatIconProps {
+    /** Outer width/height in points. Default 24. */
+    size?: number;
+    /** Fill color of the bubble. Default white. */
+    color?: string;
+}
+/**
+ * Default chat-bubble icon used by the AppilotsChat FAB.
+ *
+ * Designed to be edited:
+ *   - tweak `size` / `color` via props at the call site
+ *   - edit the SVG `d` path below to customize the shape
+ *   - or pass your own React node via the AppilotsChat `triggerIcon`
+ *     prop and this component is never rendered
+ *
+ * Implemented with react-native-svg so the result is crisp at any
+ * size and works consistently across iOS / Android. The previous
+ * emoji-based icon (💬) was unreliable when the device's emoji font
+ * did not have the glyph or when an enclosing fontFamily blocked the
+ * Apple Color Emoji fallback — it rendered as a `?`-in-box tofu.
+ */
+declare function ChatIcon({ size, color }: ChatIconProps): React$1.JSX.Element;
+
+interface HeadsetIconProps {
+    /** Outer width/height in points. Default 18. */
+    size?: number;
+    /** Fill color. Default white. */
+    color?: string;
+}
+/**
+ * Headset glyph for the "talk to a human" header button
+ * (docs/human-escalation.md). Same react-native-svg approach as
+ * ChatIcon — crisp at any size, no emoji-font tofu.
+ */
+declare function HeadsetIcon({ size, color }: HeadsetIconProps): React$1.JSX.Element;
+
+/**
+ * ListRegistry — runtime metadata for list/collection components.
+ *
+ * Fiber walking can see currently-mounted rows, but list components
+ * know facts the visible subtree may not expose: total item count,
+ * refreshing/empty state, and a stable collection id. Auto-tracking
+ * registers that metadata here so snapshots can describe collections
+ * without relying only on structural guesses.
+ */
+interface ListDataPreviewEntry$1 {
+    /** 0-based index in the list's backing data. */
+    index: number;
+    /** Stable key from keyExtractor / item.id when available. */
+    key?: string;
+    /** Short human-readable projection of the item (capped length). */
+    text: string;
+}
+interface ListScrollMetrics {
+    /** Current vertical scroll offset in px. */
+    offset: number;
+    /** Viewport length in px. */
+    visibleLength: number;
+    /** Total scrollable content length in px. */
+    contentLength: number;
+}
+interface ListEntry {
+    kind: 'list';
+    /** Stable runtime id assigned from testID/accessibilityLabel or generated. */
+    id: string;
+    /** Component name: FlatList, SectionList, VirtualizedList, FlashList, etc. */
+    component: string;
+    /** Total items in the backing data set when the component exposes it. */
+    itemCount?: number;
+    /** Human-readable label if the app supplied one. */
+    label?: string;
+    /** Screen where this list is registered, when available. */
+    screen?: string;
+    /** Loading/refreshing state exposed by RN list props. */
+    refreshing?: boolean;
+    /** True when itemCount is known and zero. */
+    empty?: boolean;
+    /**
+     * Lightweight text projection of the FULL data set (capped). Built by
+     * the auto-tracking wrapper from `props.data` so the agent can see
+     * rows that virtualization keeps unmounted.
+     */
+    dataPreview?: ListDataPreviewEntry$1[];
+    /** Scroll so the 0-based data index becomes visible. Returns false when unsupported. */
+    scrollToIndex?: (index: number) => boolean;
+    /** Scroll to an absolute pixel offset. Returns false when unsupported. */
+    scrollToOffset?: (offset: number) => boolean;
+    /** Read live scroll metrics off the component instance, when possible. */
+    getScrollMetrics?: () => ListScrollMetrics | undefined;
+}
+type Listener$1 = (id: string, entry: ListEntry | null) => void;
+type ListRegistry = ListRegistryImpl;
+declare class ListRegistryImpl {
+    private lists;
+    private listeners;
+    register(id: string, entry: ListEntry): void;
+    unregister(id: string): void;
+    get(id: string): ListEntry | undefined;
+    snapshot(): ListEntry[];
+    subscribe(listener: Listener$1): () => void;
+    clear(): void;
+    get size(): number;
+    private notify;
+}
+declare const listRegistry: ListRegistry;
+declare function createListRegistry(): ListRegistry;
+
+/**
+ * Snapshot types — the shape of data captured from the React fiber tree.
+ *
+ * This is the runtime "view model" of what the user is currently seeing
+ * on screen, sent to the AI agent so it has accurate visible state.
+ */
+interface InputSnapshot {
+    /** Best identifier — testID, accessibilityLabel, or placeholder */
+    id?: string;
+    /** Human-readable label inferred from accessibilityLabel, label prop, or sibling Text */
+    label?: string;
+    /** Current value (only present for controlled inputs) */
+    value?: string;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Whether the input is editable */
+    editable?: boolean;
+    /** Whether the input is secure (password field) */
+    secure?: boolean;
+    /** Inferred type based on keyboardType / secureTextEntry */
+    type?: 'text' | 'email' | 'number' | 'phone' | 'password';
+    /**
+     * True when this input lives inside a currently-visible Modal. When a
+     * modal is open, only inModal elements can actually receive touches —
+     * everything else is behind the overlay.
+     */
+    inModal?: boolean;
+}
+interface ButtonSnapshot {
+    /** Best identifier — testID, accessibilityLabel, or inferred from child text */
+    id?: string;
+    /** Human-readable label — usually the visible text inside the button */
+    label?: string;
+    /** Whether the button is disabled */
+    disabled?: boolean;
+    /**
+     * Whether the button currently appears selected/active — read from
+     * `accessibilityState.selected`. Set by grouped, mutually-exclusive
+     * controls (SegmentedControl, RadioGroup) where each option is its
+     * own pressable target; absent/false for ordinary buttons.
+     */
+    selected?: boolean;
+    /** True when this button lives inside a currently-visible Modal. */
+    inModal?: boolean;
+}
+interface ToggleSnapshot {
+    /** Best identifier — testID or accessibilityLabel */
+    id?: string;
+    /** Human-readable label */
+    label?: string;
+    /** Current on/off state */
+    value?: boolean;
+    /** True when this toggle lives inside a currently-visible Modal. */
+    inModal?: boolean;
+}
+interface SliderSnapshot {
+    /** Registry id (the id apps pass to useAppilotsSlider) — the executable handle. */
+    id?: string;
+    /** Human-readable label */
+    label?: string;
+    /** Current numeric value */
+    value?: number;
+    /** Lower bound the executor clamps to */
+    min?: number;
+    /** Upper bound the executor clamps to */
+    max?: number;
+    /** Step the executor snaps to (omitted = continuous) */
+    step?: number;
+    /** Whether the slider is currently disabled */
+    disabled?: boolean;
+    /** True when this slider lives inside a currently-visible Modal. */
+    inModal?: boolean;
+}
+interface ListItemSnapshot {
+    /** 1-indexed position within the parent list (matches "selecione o terceiro"). */
+    index: number;
+    /**
+     * 0-based index of this row in the list's backing DATA, when the
+     * auto-tracking wrapper stamped it (`__appilotsItemIndex`). For
+     * scrolled/virtualized lists this differs from `index`: the first
+     * MOUNTED row might be data item 42. Lets the prompt show absolute
+     * positions ("#43 of 100") so ordinal references stay correct.
+     */
+    dataIndex?: number;
+    /**
+     * React key of the cell, if present (typically the item's domain id
+     * from keyExtractor). Useful for the LLM when the user references an
+     * item by name and we want to surface a deterministic handle for
+     * future tap-by-ordinal resolution (Phase B).
+     */
+    reactKey?: string;
+    /** Runtime key supplied by auto-tracked list renderItem, if available. */
+    itemKey?: string;
+    /**
+     * Texts captured from this item's subtree (vehicle name, plate,
+     * tags, etc.). Per-item to preserve row association — the flat
+     * `snapshot.texts` lost it.
+     */
+    texts: string[];
+    /** Buttons inside this item — e.g. an inline "Edit" button on a row. */
+    buttons: ButtonSnapshot[];
+    /** Inputs inside this item — rare but possible (inline edit row). */
+    inputs: InputSnapshot[];
+    /** Toggles inside this item. */
+    toggles: ToggleSnapshot[];
+    /**
+     * Synthetic id assigned by the walker. Stable within a single
+     * snapshot; format `list-<L>-item-<I>` (0-indexed L, 1-indexed I).
+     * Used by Phase B's tap-by-ordinal resolution in uiInteractionHandler.
+     */
+    syntheticId: string;
+}
+interface ListSnapshot {
+    /** 0-indexed list ordinal — multiple lists on one screen get 0, 1, 2... */
+    index: number;
+    /** Runtime list id when auto-tracking or explicit props provide one. */
+    id?: string;
+    /**
+     * The container component name as observed in the fiber tree.
+     * Common values: 'FlatList', 'SectionList', 'VirtualizedList',
+     * 'FlashList', 'ScrollView' (when detected by N≥2 keyed children).
+     */
+    containerType: string;
+    /** Source that identified this list. */
+    source?: 'fiber' | 'auto-tracked' | 'registry';
+    /** Total data-set count when the list component exposes it. */
+    itemCount?: number;
+    /** Number of row items captured in this snapshot. */
+    visibleItemCount?: number;
+    /** True when the list reports a refresh/loading state. */
+    refreshing?: boolean;
+    /** True when total item count is known and zero. */
+    empty?: boolean;
+    /** Human-readable label if the app supplied one. */
+    label?: string;
+    /**
+     * Items in visible order. Real list components may expose one mounted
+     * item when virtualization or an overlay limits the visible window;
+     * heuristic ScrollView lists still require at least two list-like items.
+     */
+    items: ListItemSnapshot[];
+    /**
+     * Lightweight text projection of the list's FULL data set (capped),
+     * captured by the auto-tracking wrapper from `props.data`. Lets the
+     * agent see/search rows that virtualization keeps unmounted. Each
+     * entry: 0-based data index, stable key (keyExtractor), short text.
+     */
+    dataPreview?: ListDataPreviewEntry[];
+    /** Current vertical scroll offset in px, when the SDK could read it. */
+    scrollOffsetY?: number;
+    /** True when there is scrollable content above the viewport. */
+    canScrollUp?: boolean;
+    /** True when there is scrollable content below the viewport. */
+    canScrollDown?: boolean;
+}
+interface ListDataPreviewEntry {
+    /** 0-based index in the list's backing data. */
+    index: number;
+    /** Stable key from keyExtractor / item.id when available. */
+    key?: string;
+    /** Short human-readable projection of the item (capped length). */
+    text: string;
+}
+interface ChoiceOptionSnapshot {
+    /** 1-indexed option position within this group. */
+    index: number;
+    /** Stable-enough id for the current snapshot/action turn. */
+    syntheticId: string;
+    /** Best target id if this option is backed by a pressable component. */
+    targetId?: string;
+    /** Human-readable option label. */
+    label?: string;
+    /** Text segments that belong to this option. */
+    texts: string[];
+    /** Whether this option appears selected. */
+    selected?: boolean;
+    /** Whether this option appears disabled. */
+    disabled?: boolean;
+}
+interface ChoiceGroupSnapshot {
+    /** 0-indexed group ordinal on the current screen. */
+    index: number;
+    /** Runtime id when known, usually inherited from a list/collection. */
+    id?: string;
+    /** Human-readable label when known. */
+    label?: string;
+    /** Source that produced this choice group. */
+    source?: 'list' | 'buttons' | 'heuristic';
+    /** Visible options in order. */
+    options: ChoiceOptionSnapshot[];
+}
+interface InteractionElementListContext {
+    listIndex?: number;
+    listId?: string;
+    listLabel?: string;
+    itemIndex?: number;
+    itemKey?: string;
+    reactKey?: string;
+    syntheticId?: string;
+}
+interface InteractionElementSnapshot {
+    /** Stable id for the current screen/content, preferred for tool calls. */
+    id: string;
+    /** Semantic UI role. */
+    role: 'option' | 'button' | 'input' | 'toggle' | 'slider' | 'listItem';
+    /** Human-readable label. */
+    label?: string;
+    /** Text segments associated with this element. */
+    texts: string[];
+    /** Actions supported by this element. */
+    actions: Array<'press' | 'focus' | 'toggle' | 'setValue'>;
+    /** Whether the element is currently disabled. */
+    disabled?: boolean;
+    /** Whether the element appears selected. */
+    selected?: boolean;
+    /** Source that produced the element. */
+    source?: 'list' | 'button' | 'input' | 'toggle' | 'slider' | 'choice';
+    /** Legacy/fallback target id, if any. */
+    targetId?: string;
+    /** Context for row/list options. */
+    listContext?: InteractionElementListContext;
+    /**
+     * True when the underlying component lives inside a currently-visible
+     * Modal — the only targets actually touchable while the overlay is up.
+     */
+    inModal?: boolean;
+}
+interface ScreenSnapshot {
+    /** The currently active route name, if known */
+    route: string | null;
+    /** All visible static text (text content of <Text> components) */
+    texts: string[];
+    /** All TextInput components currently rendered (and visible) */
+    inputs: InputSnapshot[];
+    /** All button-like components (TouchableOpacity, Pressable, etc.) */
+    buttons: ButtonSnapshot[];
+    /** All Switch components */
+    toggles: ToggleSnapshot[];
+    /**
+     * Sliders / adjustable numeric controls. Populated from the
+     * ComponentRegistry (useAppilotsSlider) by captureSnapshot — the
+     * registry is the only source that knows min/max/step AND can
+     * execute set_value, so observation and execution stay in contract.
+     */
+    sliders: SliderSnapshot[];
+    /** Whether an ActivityIndicator is visible (signals loading state) */
+    loading: boolean;
+    /** Whether a Modal is currently open */
+    modalOpen: boolean;
+    /**
+     * Lists detected in the visible tree. Each list's items have their
+     * own per-item texts/buttons/inputs/toggles, NOT duplicated in the
+     * flat top-level arrays — that's the whole reason this field exists,
+     * to preserve row association the flat shape destroys.
+     */
+    lists: ListSnapshot[];
+    /**
+     * Choice groups detected from visible cards/rows/chips/buttons.
+     * These are used for select-like flows where no TextInput exists:
+     * choose an option by pressing a row/card, then advance.
+     */
+    choiceGroups: ChoiceGroupSnapshot[];
+    /**
+     * Interaction graph: visible actionable elements with stable ids,
+     * semantic roles, labels, and execution fallbacks. Agents should
+     * prefer these ids over synthetic ordinal handles.
+     */
+    elements: InteractionElementSnapshot[];
+    /** Diagnostic counts for debugging */
+    stats?: {
+        visitedFibers: number;
+        skippedHidden: number;
+    };
+}
+
+type InteractionElementEntry = InteractionElementSnapshot;
+type Listener = (id: string, entry: InteractionElementEntry | null) => void;
+type ElementRegistry = ElementRegistryImpl;
+declare class ElementRegistryImpl {
+    private elements;
+    private listeners;
+    replaceAll(elements: InteractionElementEntry[]): void;
+    register(id: string, entry: InteractionElementEntry): void;
+    unregister(id: string): void;
+    get(id: string): InteractionElementEntry | undefined;
+    snapshot(): InteractionElementEntry[];
+    subscribe(listener: Listener): () => void;
+    clear(): void;
+    get size(): number;
+    private notify;
+}
+declare const elementRegistry: ElementRegistry;
+declare function createElementRegistry(): ElementRegistry;
+
+/**
+ * AppilotsRegistryProvider + useResolvedRegistry — opt-in scoping of
+ * the ComponentRegistry for multi-tenant / micro-front-end setups.
+ *
+ * Apps with a single Appilots session don't need this — the global
+ * `componentRegistry` singleton works exactly as before. Pré-mortem
+ * 2.8 flagged the singleton as a future risk when two Appilots
+ * sessions might run in the same JS process; this Provider lets that
+ * case isolate without breaking the existing API.
+ */
+
+/**
+ * Scope all child Appilots hooks, auto-tracked components, and action
+ * handlers to a specific ComponentRegistry instance instead of the
+ * global singleton.
+ *
+ * Pass the result of `createComponentRegistry()` as `value`. Anything
+ * rendered inside this Provider that uses Appilots hooks
+ * (useAppilotsField/Target/Toggle) or that is auto-tracked will
+ * register here.
+ */
+declare function AppilotsRegistryProvider({ value, children, }: {
+    value: ComponentRegistry;
+    children: React__default.ReactNode;
+}): React__default.ReactElement;
+/**
+ * Resolve the active ComponentRegistry. Returns the one provided by
+ * the nearest `<AppilotsRegistryProvider>` if any, otherwise the
+ * module-level singleton. Safe to call outside of React (e.g. from
+ * action handlers) — context lookup is best-effort.
+ *
+ * Used internally by the SDK; most app code should not need this.
+ */
+declare function useResolvedRegistry(): ComponentRegistry;
+
+/**
+ * initAppilots — SDK initialisation & auto-config resolution.
+ *
+ * The preferred setup is fully automatic:
+ *
+ * 1. Add `withAppilots()` to your metro.config.js (one-time):
+ * ```js
+ * const { withAppilots } = require('@appilots/sdk/metro');
+ * module.exports = withAppilots(mergeConfig(defaultConfig, config));
+ * ```
+ *
+ * 2. Create a `.appilotsrc` JSON file at the project root.
+ *
+ * 3. Use AppilotsProvider with zero props — config is loaded automatically:
+ * ```tsx
+ * <AppilotsProvider>
+ *   <App />
+ *   <AppilotsChat />
+ * </AppilotsProvider>
+ * ```
+ *
+ * You can also call initAppilots() manually if you prefer explicit control:
+ * ```tsx
+ * initAppilots({ projectId: 'my-app', apiKey: 'ak_...' });
+ * ```
+ */
+
+interface AppilotsRC {
+    /** Project ID from the Appilots dashboard */
+    projectId: string;
+    /** SDK API key (ak_...) */
+    apiKey?: string;
+    /** API base URL (defaults to https://api.appilots.com) */
+    apiBaseUrl?: string;
+    /** Alias for apiBaseUrl (supported for convenience) */
+    apiUrl?: string;
+    /** Agent permissions */
+    permissions?: Partial<AgentPermissions>;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Auto-tracking options */
+    autoTracking?: {
+        /** Enable auto-tracking (default: true) */
+        enabled?: boolean;
+        /** Also track Pressable components */
+        trackPressable?: boolean;
+    };
+}
+/**
+ * Initialize the Appilots SDK manually. Call once at app startup.
+ *
+ * @param config - Config object (inline or from require('./.appilotsrc'))
+ */
+declare function initAppilots(config: AppilotsRC): void;
+/**
+ * Get the global config set by initAppilots() or auto-config.
+ * Used internally by AppilotsProvider when no config prop is passed.
+ */
+declare function getGlobalConfig(): AppilotsRC | null;
+
+/**
+ * enableAppilotsAutoTracking — Zero-config auto-registration of UI components.
+ *
+ * Call this ONCE at app startup (before any rendering). It patches
+ * React.createElement to automatically wrap TextInput, Switch, and
+ * TouchableOpacity/Pressable with ComponentRegistry registration.
+ *
+ * Components are identified by their `testID`, `accessibilityLabel`,
+ * or `placeholder` props. No changes needed in any component file.
+ *
+ * Usage:
+ * ```tsx
+ * // App.tsx — just this ONE line at the top
+ * import { enableAppilotsAutoTracking } from '@appilots/sdk';
+ * enableAppilotsAutoTracking();
+ * ```
+ *
+ * That's it. Every TextInput with a testID/accessibilityLabel/placeholder
+ * in your entire app will auto-register with the AI agent.
+ */
+
+/**
+ * Enable automatic tracking of all UI components in the app.
+ * Call once at app startup, before any rendering.
+ *
+ * @param options - Optional configuration
+ */
+declare function enableAppilotsAutoTracking(options?: {
+    /** Also track Pressable components (default: true) */
+    trackPressable?: boolean;
+    /** Debug mode — log registrations to console */
+    debug?: boolean;
+}): void;
+/**
+ * Patch JSX runtime modules from the app context.
+ * Called by the metro.js shim because the SDK's compiled require()
+ * may not resolve react/jsx-runtime correctly (tsup __require issue).
+ *
+ * @internal — not part of the public API
+ */
+declare function _patchJsxRuntimes(jsxRuntime: any, jsxDevRuntime: any): void;
+/**
+ * Check if auto-tracking is enabled.
+ */
+declare function isAutoTrackingEnabled(): boolean;
+
+type TraceListener = (entries: AppilotsTraceEntry[]) => void;
+declare function recordAppilotsDebugTrace(entry: Omit<AppilotsTraceEntry, 'id'> & {
+    id?: string;
+}): void;
+declare function getAppilotsDebugTraces(): AppilotsTraceEntry[];
+declare function clearAppilotsDebugTraces(): void;
+declare function subscribeAppilotsDebugTraces(listener: TraceListener): () => void;
+
+/**
+ * captureSnapshot — the public entry point for runtime UI introspection.
+ *
+ * Call this just before sending a message to the AI agent. It walks
+ * the React fiber tree starting from AppilotsProvider's children and
+ * returns a structured snapshot of everything currently rendered and
+ * visible on screen.
+ *
+ * Combined with the MCP document (design-time structure) and the
+ * navigation state (which route is active), this gives the AI model
+ * full awareness of the user's current view.
+ */
+
+declare function captureSnapshot(): ScreenSnapshot;
+
+/**
+ * createAppilotsInput — HOC factory that wraps any TextInput-like component
+ * and auto-registers it with the ComponentRegistry.
+ *
+ * Usage (ONE TIME in the component definition file):
+ * ```tsx
+ * // components/Input.tsx
+ * import { createAppilotsInput } from '@appilots/sdk';
+ *
+ * function BaseInput({ label, value, onChangeText, ...rest }) {
+ *   return <TextInput value={value} onChangeText={onChangeText} {...rest} />;
+ * }
+ *
+ * // Wrap it — that's it!
+ * export const Input = createAppilotsInput(BaseInput);
+ * ```
+ *
+ * Now every usage auto-registers:
+ * ```tsx
+ * <Input label="E-mail" value={email} onChangeText={setEmail} />
+ * // Auto-registered as field "email" (normalized from label)
+ * ```
+ *
+ * Optional explicit ID:
+ * ```tsx
+ * <Input appilotsId="userEmail" label="E-mail" value={email} onChangeText={setEmail} />
+ * ```
+ */
+
+/** Props that the HOC adds to the wrapped component */
+interface AppilotsInputProps {
+    /** Explicit Appilots field ID. If omitted, auto-derived from `label` prop. */
+    appilotsId?: string;
+    /** Screen name for scoping. If omitted, registers globally. */
+    appilotsScreen?: string;
+    /** Field type hint. Default: 'text' */
+    appilotsFieldType?: FieldEntry['fieldType'];
+    /** Set to false to disable auto-registration for this instance. */
+    appilotsEnabled?: boolean;
+    /**
+     * Marks this field's value as sensitive (password/PIN/CVV/API key/etc.)
+     * for inputs that can't rely on `secureTextEntry` — e.g. a custom-styled
+     * masked field, or a credential entered via a non-password keyboard.
+     * Forces `secure: true` on the runtime snapshot, which every downstream
+     * redaction layer (prompt serialization, persisted-payload redaction,
+     * breadcrumb) already honors. Requires `WrappedComponent` to forward
+     * unknown props (including this one) down to its underlying `TextInput`.
+     */
+    appilotsSensitive?: boolean;
+}
+/**
+ * Creates an enhanced Input component that auto-registers with Appilots.
+ *
+ * The wrapped component MUST accept these props:
+ * - `label` (string) — used as auto-ID source
+ * - `value` (string) — current field value
+ * - `onChangeText` (function) — value setter
+ *
+ * @param WrappedComponent - Your existing Input component
+ * @returns Enhanced component with auto-registration
+ */
+declare function createAppilotsInput<P extends {
+    label?: string;
+    value?: string;
+    onChangeText?: (text: string) => void;
+}>(WrappedComponent: React__default.ComponentType<P>): React__default.ComponentType<P & AppilotsInputProps>;
+
+/**
+ * createAppilotsButton — HOC factory that wraps any Button/Pressable component
+ * and auto-registers it as a target in the ComponentRegistry.
+ *
+ * Usage:
+ * ```tsx
+ * import { createAppilotsButton } from '@appilots/sdk';
+ *
+ * function BaseButton({ title, onPress, ...rest }) {
+ *   return <TouchableOpacity onPress={onPress}><Text>{title}</Text></TouchableOpacity>;
+ * }
+ *
+ * export const Button = createAppilotsButton(BaseButton);
+ * ```
+ *
+ * Now every usage auto-registers:
+ * ```tsx
+ * <Button title="Cadastrar Veículo" onPress={handleSubmit} />
+ * // Auto-registered as target "cadastrarVeiculo"
+ * ```
+ */
+
+interface AppilotsButtonProps {
+    /** Explicit Appilots target ID. If omitted, auto-derived from `title` prop. */
+    appilotsId?: string;
+    /** Screen name for scoping. */
+    appilotsScreen?: string;
+    /** Set to false to disable auto-registration. */
+    appilotsEnabled?: boolean;
+}
+declare function createAppilotsButton<P extends {
+    title?: string;
+    onPress?: () => void;
+}>(WrappedComponent: React__default.ComponentType<P>): React__default.ComponentType<P & AppilotsButtonProps>;
+
+/**
+ * createAppilotsSwitch — HOC factory that wraps any Switch/Toggle component
+ * and auto-registers it in the ComponentRegistry.
+ *
+ * Usage:
+ * ```tsx
+ * import { createAppilotsSwitch } from '@appilots/sdk';
+ *
+ * function BaseToggle({ label, value, onValueChange, ...rest }) {
+ *   return <Switch value={value} onValueChange={onValueChange} />;
+ * }
+ *
+ * export const Toggle = createAppilotsSwitch(BaseToggle);
+ * ```
+ *
+ * Auto-registers using `label` prop:
+ * ```tsx
+ * <Toggle label="Push Notifications" value={push} onValueChange={setPush} />
+ * // Registered as toggle "pushNotifications"
+ * ```
+ */
+
+interface AppilotsSwitchProps {
+    /** Explicit Appilots toggle ID. If omitted, auto-derived from `label` prop. */
+    appilotsId?: string;
+    /** Screen name for scoping. */
+    appilotsScreen?: string;
+    /** Set to false to disable auto-registration. */
+    appilotsEnabled?: boolean;
+}
+declare function createAppilotsSwitch<P extends {
+    label?: string;
+    value?: boolean;
+    onValueChange?: (value: boolean) => void;
+}>(WrappedComponent: React__default.ComponentType<P>): React__default.ComponentType<P & AppilotsSwitchProps>;
+
+/**
+ * navigateHandler — Executes navigation actions using the React Navigation ref.
+ *
+ * Supports: navigate, push, replace, goBack, reset.
+ */
+
+/**
+ * Structured diagnosis attached to a failed action result (BACKLOG 3.2).
+ * Travels through the executor → useAppilotsChat → /agent/continue so the
+ * server can build a recovery-flavored observation for the model.
+ *
+ * This shape is intentionally a subset of @appilots/shared's
+ * `actionDiagnoseSchema`; we duplicate the literal types here to
+ * avoid forcing the SDK to pull a Zod runtime dep just for this.
+ */
+type ActionFailureCategory = 'component-not-found' | 'disabled' | 'validation' | 'network-5xx' | 'network-4xx' | 'screen-timeout' | 'ambiguous-target' | 'unknown';
+interface ActionDiagnose {
+    category: ActionFailureCategory;
+    /** Visible validation message read off the screen, when available */
+    visibleMessage?: string;
+    /** Field id (form_fill failures) */
+    fieldId?: string;
+    /** Component id (ui_interaction failures) */
+    targetId?: string;
+    /** Route name when the failure happened */
+    screen?: string;
+    /** HTTP status when category is `network-*` */
+    httpStatus?: number;
+    /**
+     * When resolution failed because MULTIPLE on-screen targets matched
+     * with equal confidence, the candidate ids/labels are listed here so
+     * the server's recovery hop can offer the model a concrete choice
+     * instead of a blind retry. Capped at 8 entries.
+     */
+    candidates?: string[];
+    /** Optional generic recovery signal; omitted means server derives it. */
+    recoverable?: boolean;
+    /** True when safe continuation needs more user-provided information. */
+    requiresUserInput?: boolean;
+}
+interface ActionResult {
+    success: boolean;
+    error?: string;
+    /**
+     * Structured failure detail. Populated by handlers when they can
+     * tell *why* a call failed (registry miss, disabled button, etc.)
+     * — feeds the recovery loop on the server side.
+     */
+    diagnose?: ActionDiagnose;
+    /**
+     * Optional visible effect signal. Older handlers omit it; the server
+     * still falls back to success + toolWithoutEffect.
+     */
+    effect?: 'unknown' | 'none' | 'partial' | 'changed' | 'completed';
+    /** Optional localized status key for UI surfaces that support it. */
+    userVisibleStatusKey?: string;
+}
+
+/**
+ * ActionExecutor — Central dispatcher that routes agent actions
+ * to the appropriate handler based on action type.
+ *
+ * Used by useAppilotsActions.approveAction() to actually execute
+ * the action against the live UI.
+ */
+
+interface ExecutorContext {
+    /** React Navigation ref for navigate actions */
+    navigationRef: React.MutableRefObject<any>;
+    /** SDK permissions from AppilotsConfig */
+    permissions: AgentPermissions;
+    /** Event emitter from AppilotsProvider */
+    emit: (event: AppilotsEvent) => void;
+    /**
+     * Optional component registry override. When the SDK is used in a
+     * multi-tenant / micro-front-end setup, the caller passes the
+     * registry obtained from `<AppilotsRegistryProvider>` here so action
+     * handlers operate on the correct registry instance. When omitted,
+     * handlers use the global singleton (`getDefaultRegistry()`) — the
+     * historical behavior.
+     */
+    registry?: ComponentRegistry;
+}
+declare function executeAction(action: AgentAction, context: ExecutorContext): Promise<ActionResult>;
+
+/**
+ * SDK version — bumped by changesets on release. Lives in its own module
+ * so runtime code (AppilotsClient) can import it without pulling the whole
+ * public barrel in and creating an import cycle.
+ */
+declare const SDK_VERSION = "0.1.0";
+
+export { ActionBreadcrumb, type ActionBreadcrumbProps, type ActionResult, AgentAction, AgentPermissions, type AppilotsButtonProps, AppilotsChat, type AppilotsChatMode, type AppilotsChatPosition, type AppilotsChatProps, type AppilotsChatTheme, AppilotsEvent, type AppilotsInputProps, AppilotsLocale, type AppilotsRC, AppilotsRegistryProvider, type AppilotsSwitchProps, AppilotsThemeProvider, type AppilotsThemeProviderProps, AppilotsThemeTokens, AppilotsTraceEntry, type BreadcrumbItem, type BreadcrumbState, type ButtonSnapshot, ChatIcon, type ChatIconProps, type ChoiceGroupSnapshot, type ChoiceOptionSnapshot, ComponentRegistry, ConfirmDialog, type ConfirmDialogProps, type ElementRegistry, type ExecutorContext, FieldEntry, HeadsetIcon, type HeadsetIconProps, type InputSnapshot, type InteractionElementEntry, type InteractionElementListContext, type InteractionElementSnapshot, type ListEntry, type ListItemSnapshot, type ListRegistry, type ListSnapshot, PartialThemeTokens, SDK_VERSION, type ScreenSnapshot, type TailwindResolvedConfig, type ToggleSnapshot, _patchJsxRuntimes, appilotsTheme, appilotsThemeFromTailwind, captureSnapshot, clearAppilotsDebugTraces, createAppilotsButton, createAppilotsInput, createAppilotsSwitch, createElementRegistry, createListRegistry, describeAction, elementRegistry, enableAppilotsAutoTracking, executeAction, getAppilotsDebugTraces, getGlobalConfig, humanizeError, initAppilots, isAutoTrackingEnabled, listRegistry, recordAppilotsDebugTrace, subscribeAppilotsDebugTraces, useAppilotsTheme, useResolvedRegistry };