@ateam-ai-mobile/plugin-runtime 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,1129 @@
+import React$1, { MutableRefObject, ReactNode, ComponentType } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as zustand from 'zustand';
+import * as react_native from 'react-native';
+import { View, TextInput } from 'react-native';
+export { ActivityIndicator, Animated, FlatList, Image, Modal, Platform, Pressable, RefreshControl, ScrollView, SectionList, StyleSheet, Switch, Text, TextInput, TouchableOpacity, View } from 'react-native';
+
+/**
+ * @adas/plugin-sdk — Type definitions
+ *
+ * This is the developer contract for native mobile plugins.
+ * Both UI and service plugins use these interfaces.
+ */
+interface PluginContext {
+    tenant: string;
+    pluginId: string;
+    connectorId?: string;
+    user?: {
+        id: string;
+        name: string;
+        roles: string[];
+    };
+}
+interface PluginBridge {
+    /** Wait for host initialization */
+    onInit(cb: (ctx: PluginContext) => void): void;
+    /** Call an MCP tool on any connector */
+    mcpCall(tool: string, args: any, connectorId?: string): Promise<any>;
+    /** Raw JSON-RPC to /mcp endpoint */
+    mcpFetch(body: any): Promise<any>;
+    /** Send a command to the host */
+    sendCommand(type: string, payload: any): void;
+    /** Listen for commands from the host */
+    onCommand(cb: (type: string, payload: any) => void): () => void;
+    /** Close this plugin and return to chat */
+    close(): void;
+    /** Post a message into the user's chat thread, exactly as if the user
+     *  typed it. Use for confirmed user actions (e.g. "Connect Gmail" with
+     *  an approval modal) that should kick off a flow the orchestrator
+     *  already knows how to handle. Pair with `close()` to land the user on
+     *  the chat screen so they see Ada working on it. */
+    sendMessage(text: string): void;
+    /** Pre-fill the chat composer with `text` without sending. The user lands
+     *  on chat with the text already typed and the input focused, so they can
+     *  edit/review before tapping send. Use for "draft a message about X"
+     *  flows where you want the user to review before committing. Pair with
+     *  `close()` to dismiss the plugin surface. */
+    prepareMessage(text: string): void;
+}
+interface CameraAPI {
+    takePhoto(opts?: {
+        quality?: number;
+        facing?: 'front' | 'back';
+    }): Promise<{
+        uri: string;
+        width: number;
+        height: number;
+    }>;
+    scanBarcode(opts?: {
+        formats?: string[];
+    }): Promise<{
+        data: string;
+        format: string;
+    }>;
+    pickImage(opts?: {
+        multiple?: boolean;
+    }): Promise<{
+        uri: string;
+    }[]>;
+}
+interface LocationAPI {
+    getCurrent(opts?: {
+        accuracy?: 'low' | 'high';
+    }): Promise<{
+        latitude: number;
+        longitude: number;
+        altitude?: number;
+    }>;
+    watchPosition(cb: (pos: {
+        latitude: number;
+        longitude: number;
+    }) => void): () => void;
+}
+interface StorageAPI {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    db: {
+        execute(sql: string, params?: any[]): Promise<{
+            rows: any[];
+            changes: number;
+        }>;
+    };
+}
+interface BiometricsAPI {
+    isAvailable(): Promise<boolean>;
+    authenticate(opts: {
+        reason: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+}
+interface NotificationsAPI {
+    schedule(opts: {
+        title: string;
+        body: string;
+        trigger: {
+            seconds?: number;
+            date?: string;
+        };
+    }): Promise<string>;
+    cancel(id: string): Promise<void>;
+    onReceived(cb: (notification: {
+        id: string;
+        title: string;
+        body: string;
+        data?: any;
+    }) => void): () => void;
+}
+interface HapticsAPI {
+    impact(style: 'light' | 'medium' | 'heavy'): void;
+    notification(type: 'success' | 'warning' | 'error'): void;
+    selection(): void;
+}
+interface ConnectivityAPI {
+    isOnline(): boolean;
+    onChange(cb: (online: boolean) => void): () => void;
+}
+interface FileSystemAPI {
+    readFile(path: string): Promise<string>;
+    writeFile(path: string, content: string): Promise<void>;
+    pickDocument(opts?: {
+        types?: string[];
+    }): Promise<{
+        uri: string;
+        name: string;
+        size: number;
+    }>;
+}
+interface WebViewCookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: 'Lax' | 'Strict' | 'None';
+}
+interface CookiesAPI {
+    /** Get all cookies attached to a URL's effective domain. */
+    get(url: string): Promise<WebViewCookie[]>;
+    /** Clear cookies for a domain (e.g. to force re-login). */
+    clear(url: string): Promise<{
+        ok: boolean;
+    }>;
+}
+interface SharingAPI {
+    /** Is the share sheet available on this device? */
+    isAvailable(): Promise<boolean>;
+    /** Share a local file URI via the OS share sheet. */
+    shareFile(fileUri: string, opts?: {
+        mimeType?: string;
+        UTI?: string;
+        dialogTitle?: string;
+    }): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+}
+interface ScannerAPI {
+    /** Prompt the user for camera permission. */
+    requestPermissions(): Promise<{
+        granted: boolean;
+        status: string;
+    }>;
+}
+interface NfcNdefRecord {
+    type: string;
+    payload: string;
+}
+interface NfcAPI {
+    /** Is NFC hardware present? */
+    isSupported(): Promise<boolean>;
+    /** Is NFC turned on? (Android has a toggle; iOS always enabled when supported.) */
+    isEnabled(): Promise<boolean>;
+    /** Read the next NFC tag presented to the device within the timeout. */
+    readOnce(timeoutMs?: number): Promise<{
+        ok: boolean;
+        tagId?: string;
+        records?: NfcNdefRecord[];
+        error?: string;
+    }>;
+}
+interface BiometricsAPIv2 {
+    /** What can this device do right now? */
+    capabilities(): Promise<{
+        hasHardware: boolean;
+        isEnrolled: boolean;
+        supportedTypes: Array<'fingerprint' | 'face' | 'iris'>;
+    }>;
+    /** Prompt the user. Resolves { success } or { success:false, error }. */
+    authenticate(opts: {
+        reason: string;
+        cancelLabel?: string;
+        fallbackToPasscode?: boolean;
+    }): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+interface PluginNative {
+    camera: CameraAPI;
+    location: LocationAPI;
+    storage: StorageAPI;
+    /** @deprecated use `biometricsV2` for the native-backed API. This stub
+     *  remains for backwards compatibility. */
+    biometrics: BiometricsAPI;
+    biometricsV2: BiometricsAPIv2;
+    notifications: NotificationsAPI;
+    haptics: HapticsAPI;
+    connectivity: ConnectivityAPI;
+    fileSystem: FileSystemAPI;
+    cookies: CookiesAPI;
+    sharing: SharingAPI;
+    scanner: ScannerAPI;
+    nfc: NfcAPI;
+}
+interface NativeCapabilities$1 {
+    camera?: boolean;
+    location?: boolean;
+    biometrics?: boolean;
+    offline?: boolean;
+    backgroundTasks?: boolean;
+    fileSystem?: boolean;
+    notifications?: boolean;
+    bluetooth?: boolean;
+    haptics?: boolean;
+    /** Read the platform cookie jar after a WebView login flow. */
+    cookies?: boolean;
+    /** Render a native WebView (the plugin uses react-native-webview directly). */
+    webview?: boolean;
+    /** Native share sheet. */
+    sharing?: boolean;
+    /** Camera-based QR / barcode scanning. */
+    scanner?: boolean;
+    /** NFC tag reading (iOS entitlement + Android permission required). */
+    nfc?: boolean;
+    /** Real biometric auth (Face ID / Touch ID / fingerprint). */
+    biometricsV2?: boolean;
+}
+interface PluginHooks$1 {
+    onAppStart?: boolean;
+    onPushReceived?: boolean;
+    onConnectivity?: boolean;
+    onForeground?: boolean;
+    onBackground?: boolean;
+}
+interface ThemeTokens {
+    colors: {
+        bg: string;
+        surface: string;
+        surfaceAlt: string;
+        input: string;
+        border: string;
+        text: string;
+        textSecondary: string;
+        textMuted: string;
+        accent: string;
+        accentSoft: string;
+        success: string;
+        successSoft: string;
+        warning: string;
+        warningSoft: string;
+        error: string;
+        errorSoft: string;
+        purple: string;
+        purpleSoft: string;
+    };
+    spacing: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+        xxl: number;
+    };
+    fontSize: {
+        xs: number;
+        sm: number;
+        md: number;
+        lg: number;
+        xl: number;
+    };
+    borderRadius: {
+        sm: number;
+        md: number;
+        lg: number;
+        full: number;
+    };
+    isDark: boolean;
+}
+interface PluginProps {
+    bridge: PluginBridge;
+    native: PluginNative;
+    theme: ThemeTokens;
+    context: PluginContext;
+    /** Engine-supplied props from `sys.focusUiPlugin(pluginId, props)`.
+     *  Plugins read these on first mount to support flows like "open with the
+     *  add modal pre-shown" or "prefill text X". Undefined when the plugin was
+     *  opened by the user (no props from engine). */
+    props?: any;
+}
+type RenderMode = {
+    mode: 'iframe';
+    iframeUrl: string;
+    external?: boolean;
+} | {
+    mode: 'react-native';
+    component: string;
+    bundleId?: string;
+    bundleUrl?: string;
+} | {
+    mode: 'adaptive';
+    iframe: {
+        iframeUrl: string;
+        external?: boolean;
+    };
+    reactNative: {
+        component: string;
+        bundleId?: string;
+        bundleUrl?: string;
+    };
+};
+interface PluginManifest$1 {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    type?: 'ui' | 'service' | 'hybrid';
+    render?: RenderMode;
+    native?: NativeCapabilities$1;
+    hooks?: PluginHooks$1;
+    channels?: string[] | {
+        events: string[];
+        actions: string[];
+    };
+    capabilities?: Record<string, unknown>;
+    _source?: string;
+    _connectorId?: string;
+    _mcpEndpoint?: string;
+}
+interface RegisteredUIPlugin {
+    id: string;
+    type: 'ui' | 'hybrid';
+    capabilities?: NativeCapabilities$1;
+    Component: React.FC<PluginProps>;
+}
+interface RegisteredServicePlugin {
+    id: string;
+    type: 'service';
+    capabilities?: NativeCapabilities$1;
+    hooks?: PluginHooks$1;
+    onStart: (props: Omit<PluginProps, 'theme'>) => Promise<void> | void;
+    onStop?: () => Promise<void> | void;
+}
+type RegisteredPlugin = RegisteredUIPlugin | RegisteredServicePlugin;
+
+/**
+ * Plugin registration API.
+ * Solution developers use these to register their plugins.
+ */
+
+/**
+ * Register a UI or hybrid plugin (has a visual component).
+ */
+declare function register(id: string, config: {
+    type?: 'ui' | 'hybrid';
+    capabilities?: NativeCapabilities$1;
+    Component: React.FC<PluginProps>;
+}): RegisteredUIPlugin;
+/**
+ * Register a headless service plugin (no UI).
+ */
+declare function registerService(id: string, config: {
+    capabilities?: NativeCapabilities$1;
+    hooks?: PluginHooks$1;
+    onStart: (props: Omit<PluginProps, 'theme'>) => Promise<void> | void;
+    onStop?: () => Promise<void> | void;
+}): RegisteredServicePlugin;
+
+interface CardProps {
+    theme: ThemeTokens;
+    children: React$1.ReactNode;
+    style?: any;
+    onPress?: () => void;
+}
+declare function Card({ theme, children, style, onPress }: CardProps): React$1.FunctionComponentElement<react_native.PressableProps & React$1.RefAttributes<View>> | React$1.CElement<react_native.ViewProps, View>;
+interface BadgeProps {
+    theme: ThemeTokens;
+    label: string;
+    color?: 'accent' | 'success' | 'warning' | 'error' | 'purple';
+    style?: any;
+}
+declare function Badge({ theme, label, color, style }: BadgeProps): React$1.CElement<react_native.ViewProps, View>;
+interface TabBarProps {
+    theme: ThemeTokens;
+    tabs: string[];
+    activeTab: string;
+    onTabChange: (tab: string) => void;
+    style?: any;
+}
+declare function TabBar({ theme, tabs, activeTab, onTabChange, style }: TabBarProps): React$1.CElement<react_native.ViewProps, View>;
+interface ListItemProps {
+    theme: ThemeTokens;
+    title: string;
+    subtitle?: string;
+    right?: React$1.ReactNode;
+    onPress?: () => void;
+    style?: any;
+}
+declare function ListItem({ theme, title, subtitle, right, onPress, style }: ListItemProps): React$1.FunctionComponentElement<react_native.PressableProps & React$1.RefAttributes<View>> | React$1.CElement<react_native.ViewProps, View>;
+interface SearchBarProps {
+    theme: ThemeTokens;
+    value: string;
+    onChangeText: (text: string) => void;
+    placeholder?: string;
+    style?: any;
+}
+declare function SearchBar({ theme, value, onChangeText, placeholder, style }: SearchBarProps): React$1.CElement<react_native.TextInputProps, TextInput>;
+interface EmptyStateProps {
+    theme: ThemeTokens;
+    title: string;
+    subtitle?: string;
+    style?: any;
+}
+declare function EmptyState({ theme, title, subtitle, style }: EmptyStateProps): React$1.CElement<react_native.ViewProps, View>;
+interface ErrorStateProps {
+    theme: ThemeTokens;
+    message: string;
+    onRetry?: () => void;
+    style?: any;
+}
+declare function ErrorState({ theme, message, onRetry, style }: ErrorStateProps): React$1.CElement<react_native.ViewProps, View>;
+interface LoadingStateProps {
+    theme: ThemeTokens;
+    message?: string;
+    style?: any;
+}
+declare function LoadingState({ theme, message, style }: LoadingStateProps): React$1.CElement<react_native.ViewProps, View>;
+interface ActionButtonProps {
+    theme: ThemeTokens;
+    label?: string;
+    icon?: React$1.ReactNode;
+    onPress: () => void;
+    style?: any;
+}
+declare function ActionButton({ theme, label, icon, onPress, style }: ActionButtonProps): React$1.FunctionComponentElement<react_native.PressableProps & React$1.RefAttributes<View>>;
+
+type ThemeColors = ThemeTokens['colors'];
+/** Override the plugin theme (host brand). Call once at startup — mounted
+ *  plugins re-render with the new tokens. */
+declare function setPluginThemeColors(colors: Partial<ThemeColors>, opts?: {
+    isDark?: boolean;
+}): void;
+declare function usePluginTheme(): ThemeTokens;
+
+interface PluginApi {
+    (connectorId: string, tool: string, args?: Record<string, any>): Promise<any>;
+    call(connectorOrTool: string, toolOrArgs?: string | Record<string, any>, argsOrConnector?: Record<string, any> | string): Promise<any>;
+}
+/**
+ * Create a simple API function to call connector tools.
+ */
+declare function useApi(bridge: PluginBridge): PluginApi;
+
+/**
+ * @adas/plugin-sdk namespace — everything a PLUGIN author imports.
+ * Remote bundles resolve `require('@adas/plugin-sdk')` to exactly this
+ * module via the bundle manager's require shim.
+ */
+
+declare const PluginSDK: {
+    readonly register: typeof register;
+    readonly registerService: typeof registerService;
+};
+
+/**
+ * Host integration points — the DI seams that keep this package free of
+ * Expo imports. The host app (or @ateam-ai-mobile/expo) plugs in concrete providers
+ * once at startup; everything here has a safe no-op/in-memory default so
+ * a bare host works with zero configuration.
+ */
+
+/** Register a haptics implementation (e.g. expo-haptics via @ateam-ai-mobile/expo). */
+declare function setHapticsProvider(haptics: HapticsAPI | null): void;
+/** No-op safe accessor — surfaces call this for tap feedback. */
+declare function getHaptics(): HapticsAPI | null;
+/** Install the device-capabilities implementation plugins receive as
+ *  `props.native`. The host owns the native modules. */
+declare function setPluginNativeProvider(native: PluginNative): void;
+declare function getPluginNative(): PluginNative;
+type PluginResolver = RegisteredPlugin | (() => Promise<RegisteredPlugin | null>);
+declare function registerNativePlugin(id: string, plugin: PluginResolver): void;
+declare function unregisterNativePlugin(id: string): void;
+declare const nativePluginRegistry: {
+    has(id: string): boolean;
+    get(id: string): Promise<RegisteredPlugin | null>;
+};
+declare function registerBundleModules(modules: Record<string, any>): void;
+
+declare class BundleManager {
+    /** In-memory module cache: bundleUrl → evaluated module.exports */
+    private modules;
+    /** In-flight download deduplication: bundleUrl → Promise */
+    private inflight;
+    /**
+     * Load a plugin component. Returns the RegisteredUIPlugin object.
+     * Handles: in-memory cache → disk cache → download → evaluate → extract.
+     *
+     * `expectedHash` (SHA-256 hex from cp.getContextPlugin manifest) MUST be
+     * provided for any bundle the user has not previously verified — without
+     * it, a tampered bundle is `eval`'d as JS with full RN runtime + every
+     * native capability the manifest declares.
+     */
+    load(pluginId: string, bundleUrl: string, version: string, expectedHash?: string): Promise<RegisteredUIPlugin>;
+    /**
+     * Prewarm: load every plugin bundle in the background after app boot, so a
+     * later open is instant (in-memory hit) instead of round-tripping the
+     * network. Errors are swallowed per-plugin — one bad bundle shouldn't
+     * block others. Concurrency capped at 3.
+     */
+    prewarmAll(items: Array<{
+        pluginId: string;
+        bundleUrl: string;
+        version: string;
+        bundleHash?: string;
+    }>): Promise<void>;
+    /**
+     * Clear all caches (in-memory + storage).
+     */
+    clearAll(): Promise<void>;
+    /**
+     * Clear cache for a specific plugin/bundle.
+     */
+    clearPlugin(pluginId: string): Promise<void>;
+    private loadModule;
+    /**
+     * Download + integrity-verify a bundle. Refuses to return when:
+     *   - manifest hash and computed hash disagree
+     *   - server's `X-Bundle-SHA256` disagrees with manifest hash
+     *   - no expected hash AND no server hash header (cannot prove the bundle
+     *     wasn't tampered with — fail closed rather than trust the wire).
+     */
+    private download;
+    private evaluate;
+    /**
+     * Find a plugin component in a loaded module.
+     * Handles: default export, direct key match, multi-plugin .id match.
+     */
+    private getComponentFromMemory;
+    private describeModule;
+}
+/** Singleton — shared across all plugin renderers */
+declare const bundleManager: BundleManager;
+
+/**
+ * Bundle disk-cache adapter. The bundle manager persists downloaded plugin
+ * bundles through this interface so the package stays free of Expo/RN
+ * storage imports. @ateam-ai-mobile/expo ships a file-system implementation; the
+ * default is in-memory (bundles re-download per app session — correct,
+ * just slower on cold start).
+ */
+interface BundleCacheEntry {
+    localPath: string;
+    version: string;
+    timestamp: number;
+    bundleUrl: string;
+    /** SHA-256 (hex, lowercase) of the cached bundle bytes — integrity proof */
+    bundleHash?: string;
+}
+interface BundleStorage {
+    loadIndex(): Promise<Record<string, BundleCacheEntry>>;
+    saveIndex(index: Record<string, BundleCacheEntry>): Promise<void>;
+    /** Read a cached bundle. Returns null when missing/unreadable. */
+    readBundle(localPath: string): Promise<string | null>;
+    /** Persist a bundle; returns the localPath to record in the index.
+     *  `key` is a filesystem-safe name derived from the bundle URL+version. */
+    writeBundle(key: string, content: string): Promise<string>;
+    deleteBundle(localPath: string): Promise<void>;
+    /** Wipe everything (index + bundles). */
+    clearAll(): Promise<void>;
+}
+/** Default storage: keeps bundles for the lifetime of the JS context only. */
+declare class MemoryBundleStorage implements BundleStorage {
+    private index;
+    private files;
+    loadIndex(): Promise<Record<string, BundleCacheEntry>>;
+    saveIndex(index: Record<string, BundleCacheEntry>): Promise<void>;
+    readBundle(localPath: string): Promise<string | null>;
+    writeBundle(key: string, content: string): Promise<string>;
+    deleteBundle(localPath: string): Promise<void>;
+    clearAll(): Promise<void>;
+}
+/** Install a persistent storage implementation (call before first plugin load). */
+declare function setBundleStorage(storage: BundleStorage): void;
+
+declare function useNativeBridge(pluginId: string, connectorId?: string, commandBufferRef?: MutableRefObject<any[]>): PluginBridge;
+/**
+ * Non-hook version for service plugins (no React lifecycle).
+ */
+declare function createNativeBridge(pluginId: string, connectorId?: string): PluginBridge;
+
+/**
+ * Native Bridge SDK Types
+ *
+ * TypeScript interfaces for the bridge API exposed to dynamic connectors.
+ * Connectors use these types to interact with device capabilities.
+ */
+interface CalendarEvent {
+    id: string;
+    title: string;
+    date: string;
+    start: string;
+    end: string;
+    location: string;
+    attendees: string[];
+    notes: string;
+}
+interface CalendarTodayResult {
+    date: string;
+    day_of_week: string;
+    events: CalendarEvent[];
+    count: number;
+}
+interface CalendarUpcomingResult {
+    from: string;
+    days_ahead: number;
+    events: CalendarEvent[];
+    count: number;
+}
+interface CalendarCreateParams {
+    title: string;
+    date: string;
+    start_time: string;
+    end_time?: string;
+    location?: string;
+    attendees?: string[];
+    notes?: string;
+}
+interface CalendarCreateResult {
+    event_id: string;
+}
+interface CalendarRescheduleParams {
+    event_id: string;
+    new_date?: string;
+    new_start_time?: string;
+    new_end_time?: string;
+}
+interface Contact {
+    id: string;
+    name: string;
+    phone: string | null;
+    email: string | null;
+    relationship: string;
+    birthday: string | null;
+    notes: string;
+}
+interface ContactSearchResult {
+    contacts: Contact[];
+    count: number;
+}
+interface Birthday {
+    name: string;
+    relationship: string;
+    birthday: string;
+    days_until: number;
+    is_today: boolean;
+}
+interface BirthdayResult {
+    birthdays: Birthday[];
+    count: number;
+}
+interface LocationResult {
+    lat: number;
+    lng: number;
+    place: string;
+    address: string;
+    type: string;
+    timestamp: string;
+}
+interface BatteryStatus {
+    ok: true;
+    timestamp: string;
+    battery: {
+        level: number;
+        state: 'charging' | 'unplugged' | 'full';
+        low_power_mode: boolean;
+    };
+}
+interface NetworkStatus {
+    type: 'wifi' | 'cellular' | 'none';
+    is_connected: boolean;
+    wifi_name?: string;
+    timestamp: string;
+}
+interface Notification {
+    id: string;
+    app: string;
+    title: string;
+    body: string;
+    timestamp: string;
+    sender: string | null;
+    priority: 'high' | 'medium' | 'low';
+    read: boolean;
+}
+interface NotificationListResult {
+    notifications: Notification[];
+    total: number;
+    unread: number;
+}
+interface SMSSendResult {
+    ok: boolean;
+    status: 'sent' | 'unknown' | 'cancelled';
+}
+interface MapsNavigateResult {
+    ok: boolean;
+    status: 'navigating' | 'error';
+}
+interface HttpResponse {
+    ok: boolean;
+    status: number;
+    data: any;
+    headers: Record<string, string>;
+}
+type PermissionState = 'granted' | 'denied' | 'not_requested';
+interface DeviceInfo {
+    os: 'ios' | 'android';
+    version: string;
+}
+interface Bridge {
+    calendar: {
+        getToday(): Promise<CalendarTodayResult>;
+        getUpcoming(days?: number): Promise<CalendarUpcomingResult>;
+        create(event: CalendarCreateParams): Promise<CalendarCreateResult>;
+        reschedule(params: CalendarRescheduleParams): Promise<{
+            ok: boolean;
+        }>;
+        cancel(event_id: string): Promise<{
+            ok: boolean;
+        }>;
+    };
+    contacts: {
+        search(query: string): Promise<ContactSearchResult>;
+        get(idOrName: string): Promise<Contact | null>;
+        getAll(): Promise<ContactSearchResult>;
+        birthdays(days?: number): Promise<BirthdayResult>;
+    };
+    location: {
+        getCurrent(): Promise<LocationResult>;
+    };
+    battery: {
+        getStatus(): Promise<BatteryStatus>;
+    };
+    network: {
+        getStatus(): Promise<NetworkStatus>;
+    };
+    notifications: {
+        list(): Promise<NotificationListResult>;
+    };
+    sms: {
+        isAvailable(): Promise<boolean>;
+        send(phone: string, message: string): Promise<SMSSendResult>;
+    };
+    maps: {
+        navigate(destination: string, mode?: 'driving' | 'transit' | 'walking'): Promise<MapsNavigateResult>;
+    };
+    http: {
+        get(url: string, headers?: Record<string, string>): Promise<HttpResponse>;
+        post(url: string, body: any, headers?: Record<string, string>): Promise<HttpResponse>;
+        put(url: string, body: any, headers?: Record<string, string>): Promise<HttpResponse>;
+        delete(url: string, body?: any, headers?: Record<string, string>): Promise<HttpResponse>;
+    };
+    storage: {
+        get(key: string): Promise<string | null>;
+        set(key: string, value: string): Promise<void>;
+        delete(key: string): Promise<void>;
+        keys(): Promise<string[]>;
+    };
+    permissions: {
+        check(capability: string): Promise<PermissionState>;
+        request(capability: string): Promise<boolean>;
+        getAll(): Promise<Record<string, PermissionState>>;
+    };
+    device: {
+        getDeviceId(): string;
+        getPlatform(): DeviceInfo;
+    };
+    log: {
+        info(message: string, data?: any): void;
+        warn(message: string, data?: any): void;
+        error(message: string, data?: any): void;
+    };
+}
+
+interface PluginManifestLike {
+    version?: string;
+    name?: string;
+    render?: any;
+    _connectorId?: string;
+}
+interface UsePluginResult {
+    plugin: RegisteredUIPlugin | null;
+    loading: boolean;
+    error: string | null;
+    bundleMissing: boolean;
+}
+declare function usePlugin(pluginId: string, manifest: PluginManifestLike): UsePluginResult;
+
+interface RemotePlugin {
+    id: string;
+    name: string;
+    version: string;
+    manifest: PluginManifest$1;
+    source: 'remote' | 'local';
+}
+interface UseRemotePluginsResult {
+    plugins: RemotePlugin[];
+    loading: boolean;
+    error: string | null;
+    refreshing: boolean;
+    refresh: () => Promise<void>;
+}
+/**
+ * Fetches available UI plugins from A-Team Core for the current solution.
+ * Uses apiFetch which auto-injects JWT + tenant headers.
+ */
+declare function useRemotePlugins(solutionId?: string): UseRemotePluginsResult;
+
+/**
+ * Summary returned by cp.listContextPlugins — no `render` field.
+ * Used for the plugin grid (name, icon, description).
+ */
+interface PluginSurfaceMeta {
+    type: 'drawer' | 'card' | 'fullscreen' | 'header' | 'ambient' | 'nudge';
+    visibility?: 'always' | 'user' | 'engine';
+    trigger?: {
+        from?: string;
+        gesture?: string;
+    };
+    icon?: string;
+    title?: string;
+    subtitle?: string;
+    privacy?: boolean;
+    prompt?: string;
+}
+interface PluginSummary {
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    _source?: string;
+    _connectorId?: string;
+    /** Declarative surface placement — added by the surface-SDK migration */
+    surface?: PluginSurfaceMeta;
+}
+/**
+ * Native capability flags (declared in manifest).
+ */
+interface NativeCapabilities {
+    camera?: boolean;
+    location?: boolean;
+    biometrics?: boolean;
+    offline?: boolean;
+    backgroundTasks?: boolean;
+    fileSystem?: boolean;
+    notifications?: boolean;
+    bluetooth?: boolean;
+    haptics?: boolean;
+}
+/**
+ * Lifecycle hooks for service/hybrid plugins.
+ */
+interface PluginHooks {
+    onAppStart?: boolean;
+    onPushReceived?: boolean;
+    onConnectivity?: boolean;
+    onForeground?: boolean;
+    onBackground?: boolean;
+}
+/**
+ * Render mode — polymorphic.
+ * - 'iframe': existing WebView (backward compat)
+ * - 'react-native': native RN component only
+ * - 'adaptive': both web and native, host picks best
+ */
+type PluginRenderMode = {
+    mode: 'iframe';
+    iframeUrl: string;
+    bundleUrl?: string;
+    bundleHash?: string;
+    external?: boolean;
+} | {
+    mode: 'react-native';
+    component: string;
+    bundleUrl?: string;
+    bundleHash?: string;
+    bundleId?: string;
+} | {
+    mode: 'adaptive';
+    iframe: {
+        iframeUrl: string;
+        external?: boolean;
+    };
+    reactNative: {
+        component: string;
+        bundleUrl?: string;
+        bundleHash?: string;
+        bundleId?: string;
+    };
+};
+/**
+ * Full manifest returned by cp.getContextPlugin.
+ * Extended to support native mobile plugins alongside existing web plugins.
+ */
+interface PluginManifest extends PluginSummary {
+    type?: 'ui' | 'service' | 'hybrid';
+    render: PluginRenderMode;
+    native?: NativeCapabilities;
+    hooks?: PluginHooks;
+    channels?: string[] | {
+        events: string[];
+        actions: string[];
+    };
+    capabilities?: Record<string, unknown>;
+    _mcpEndpoint?: string;
+}
+/**
+ * Determine if a manifest supports native rendering.
+ */
+declare function supportsNative(manifest: PluginManifest): boolean;
+/**
+ * Get the native component ID from a manifest (if it has native support).
+ */
+declare function getNativeComponentId(manifest: PluginManifest): string | null;
+/**
+ * Get the native bundle URL from a manifest (if it has native support).
+ */
+declare function getNativeBundleUrl(manifest: PluginManifest): string | null;
+/**
+ * Get the SHA-256 integrity hash for a native bundle, if the server provided one.
+ * Used post-download to verify the bundle bytes weren't tampered in transit
+ * — a MITM-replaced bundle gets `eval`'d as RN code with full capability access.
+ */
+declare function getNativeBundleHash(manifest: PluginManifest): string | null;
+/**
+ * Check if a manifest can be rendered as a WebView (iframe or adaptive with iframe).
+ */
+declare function supportsWebView(manifest: PluginManifest): boolean;
+/**
+ * List all available UI plugins via MCP JSON-RPC.
+ * Returns summary data only (no render field).
+ * Protocol: cp.listContextPlugins → core plugins + MCP connector plugins.
+ */
+declare function listPlugins(): Promise<PluginSummary[]>;
+/**
+ * Get a specific plugin's FULL manifest (with render.iframeUrl).
+ * Protocol: cp.getContextPlugin({ id }) → resolves iframeUrl for core/MCP/external.
+ *
+ * IMPORTANT: The backend parameter is `id`, not `pluginId`.
+ */
+declare function getPlugin(pluginId: string): Promise<PluginManifest | null>;
+/**
+ * Resolve plugin iframe URL to a full URL for WebView.
+ * Matches the web frontend's PluginHost.jsx logic:
+ * - External (absolute http): append ?tenant=
+ * - MCP plugin (/mcp-ui/...): inject tenant into path → /mcp-ui/{tenant}/{connectorId}/...
+ * - Core plugin (/assets/...): prepend getCoreApiUrl()
+ */
+declare function resolvePluginUrl(manifest: PluginManifest, tenant?: string): string;
+
+interface SurfaceDrawerProps {
+    visible: boolean;
+    onClose: () => void;
+    title: string;
+    subtitle?: string;
+    /** Show the lock + "Only you can see this" privacy pill under the title */
+    privacy?: boolean;
+    /** Show the small Ada orb in the header (default: true) */
+    showOrb?: boolean;
+    /** Sheet height ratio of screen (default: 0.85) */
+    heightRatio?: number;
+    children: ReactNode;
+}
+declare function SurfaceDrawer({ visible, onClose, title, subtitle, privacy, showOrb, heightRatio, children, }: SurfaceDrawerProps): react_jsx_runtime.JSX.Element | null;
+
+interface SurfaceCardProps {
+    /** Emoji or short string icon shown on the left */
+    icon?: string;
+    /** Card headline (e.g. "Today's plate") */
+    title: string;
+    /** Optional secondary line below title */
+    subtitle?: string;
+    /** Tap handler. Fires haptic before invoking. */
+    onPress?: () => void;
+    /** Long-press handler. Fires a heavier haptic. Used by user widgets for
+     *  the Delete / (later) Hide / Rename context menu. */
+    onLongPress?: () => void;
+    /** Whether to show the ›-style trailing arrow (default: true if onPress) */
+    showArrow?: boolean;
+    /** Optional preview content rendered below the title block */
+    children?: ReactNode;
+}
+declare function SurfaceCard({ icon, title, subtitle, onPress, onLongPress, showArrow, children, }: SurfaceCardProps): react_jsx_runtime.JSX.Element;
+
+interface SurfaceFullscreenProps {
+    visible: boolean;
+    onClose: () => void;
+    /** Status text shown under the wordmark */
+    status?: string;
+    /** Optional hero element above body (typically an AdaOrb) */
+    hero?: ReactNode;
+    /** Body content */
+    children?: ReactNode;
+    /** Whether to show the small "ada" wordmark (default: true) */
+    showWordmark?: boolean;
+    /** Built-in close icon flavor or a custom node. Default: 'x' */
+    closeIcon?: 'x' | 'hangup' | ReactNode;
+    /** Label under the close button (default: "Close") */
+    closeLabel?: string;
+}
+declare function SurfaceFullscreen({ visible, onClose, status, hero, children, showWordmark, closeIcon, closeLabel, }: SurfaceFullscreenProps): react_jsx_runtime.JSX.Element | null;
+
+type AdaOrbState = 'idle' | 'listening' | 'thinking' | 'speaking';
+interface AdaOrbProps {
+    size?: number;
+    state?: AdaOrbState;
+    /** Show the "iA" wordmark inside the orb. Suppressed below 60px because
+     *  glyphs become unreadable at avatar/chevron sizes — render as a plain
+     *  orb there. Default true. */
+    inscription?: boolean;
+}
+declare function AdaOrb({ size, state, inscription }: AdaOrbProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Surface manifest types — the contract a plugin declares to live inside
+ * the Ada host shell.
+ *
+ * Future: this maps directly onto the platform-side `surface` field on
+ * plugin manifests. While that schema is in flight, the mobile shell
+ * registers built-in surfaces locally (see bootstrap.tsx).
+ */
+
+type SurfaceType = 'drawer' | 'card' | 'fullscreen' | 'header' | 'ambient' | 'nudge';
+type SurfaceVisibility = 'always' | 'user' | 'engine';
+/** Where in the host's chrome the plugin lives. Generic, host-agnostic role.
+ *  - `featured`: signature surface — host shows it prominently (e.g. pinned card on home).
+ *  - `menu`: lives as a row in the host's navigation menu (side menu / hamburger).
+ *  - undefined: regular plugin — host puts it in the default plugin list / picker. */
+type SurfacePlacement = 'featured' | 'menu';
+interface SurfaceManifestBase {
+    /** Stable plugin/surface id. e.g. "mcp:memory:drawer" */
+    id: string;
+    type: SurfaceType;
+    visibility: SurfaceVisibility;
+    /** Optional: where in host chrome to render. Omit = default plugin list. */
+    placement?: SurfacePlacement;
+    /** Short emoji or symbol — shown on cards / header pills */
+    icon?: string;
+    title: string;
+    subtitle?: string;
+    /** Marks plugins that handle sensitive data (host shows lock pill) */
+    privacy?: boolean;
+}
+/** A surface that mounts a host component when active (drawer, fullscreen) */
+interface MountSurfaceManifest extends SurfaceManifestBase {
+    type: 'drawer' | 'fullscreen';
+    /** React component the dispatcher mounts when this surface is active.
+     *  Receives `dismiss` to close itself, plus optional `props` forwarded
+     *  from `sys.focusUiPlugin(id, props)`. */
+    Component: ComponentType<{
+        dismiss: () => void;
+        props?: any;
+    }>;
+}
+/** A surface that renders inline (card list / header / ambient) */
+interface InlineSurfaceManifest extends SurfaceManifestBase {
+    type: 'card' | 'header' | 'ambient' | 'nudge';
+    /** For cards: chat prompt to send when tapped */
+    prompt?: string;
+    /** Custom tap handler. Overrides `prompt` if present. */
+    onPress?: () => void;
+}
+type SurfaceManifest = MountSurfaceManifest | InlineSurfaceManifest;
+
+interface SurfaceState {
+    manifests: Record<string, SurfaceManifest>;
+    activeDrawer: string | null;
+    activeFullscreen: string | null;
+    /** Props passed by the engine when summoning a surface via sys.focusUiPlugin.
+     *  Keyed by surface id; cleared on hide. Plugins read these on first mount. */
+    activeProps: Record<string, any>;
+    /** Increments on every `show()` call. Used as a React `key` so the Surface
+     *  Component remounts even if the same surface is shown again — guarantees
+     *  the plugin's data-fetching effects re-run, so the user always sees fresh
+     *  data when they open a drawer. */
+    mountKey: number;
+    register: (manifest: SurfaceManifest) => void;
+    unregister: (id: string) => void;
+    /** Open a surface in its declared container. Props (optional) are forwarded
+     *  to the mounted plugin on first render. */
+    show: (id: string, props?: any) => void;
+    /** Close the surface with the given id (or whatever is active for the matching type) */
+    hide: (id?: string) => void;
+    /** All registered manifests, optionally filtered.
+     *  `placement: 'unset'` selects only plugins WITHOUT a placement (default list). */
+    list: (filter?: {
+        type?: SurfaceType;
+        visibility?: SurfaceVisibility[];
+        placement?: SurfacePlacement | 'unset';
+    }) => SurfaceManifest[];
+}
+declare const useSurfaceStore: zustand.UseBoundStore<zustand.StoreApi<SurfaceState>>;
+declare function isMountSurface(m: SurfaceManifest): m is MountSurfaceManifest;
+declare function isInlineSurface(m: SurfaceManifest): m is InlineSurfaceManifest;
+
+declare function SurfaceDispatcher(): react_jsx_runtime.JSX.Element;
+
+export { ActionButton, AdaOrb, type AdaOrbState, Badge, type BiometricsAPI, type BiometricsAPIv2, type Bridge, type BundleCacheEntry, type BundleStorage, type CameraAPI, Card, type ConnectivityAPI, type CookiesAPI, EmptyState, ErrorState, type FileSystemAPI, type HapticsAPI, type InlineSurfaceManifest, ListItem, LoadingState, type LocationAPI, MemoryBundleStorage, type MountSurfaceManifest, type NativeCapabilities$1 as NativeCapabilities, type NfcAPI, type NotificationsAPI, type PluginManifest as PlatformPluginManifest, type PluginBridge, type PluginContext, type PluginHooks$1 as PluginHooks, type PluginManifest$1 as PluginManifest, type PluginNative, type PluginProps, PluginSDK, type PluginSummary, type PluginSurfaceMeta, type RegisteredPlugin, type RegisteredServicePlugin, type RegisteredUIPlugin, type RemotePlugin, type RenderMode, type ScannerAPI, SearchBar, type SharingAPI, type StorageAPI, SurfaceCard, type SurfaceCardProps, SurfaceDispatcher, SurfaceDrawer, type SurfaceDrawerProps, SurfaceFullscreen, type SurfaceFullscreenProps, type SurfaceManifest, type SurfacePlacement, type SurfaceType, type SurfaceVisibility, TabBar, type ThemeTokens, bundleManager, createNativeBridge, getHaptics, getNativeBundleHash, getNativeBundleUrl, getNativeComponentId, getPlugin, getPluginNative, isInlineSurface, isMountSurface, listPlugins, nativePluginRegistry, register, registerBundleModules, registerNativePlugin, registerService, resolvePluginUrl, setBundleStorage, setHapticsProvider, setPluginNativeProvider, setPluginThemeColors, supportsNative, supportsWebView, unregisterNativePlugin, useApi, useNativeBridge, usePlugin, usePluginTheme, useRemotePlugins, useSurfaceStore };