@pancake-apps/web 0.0.0-snapshot-20260125200133

package/dist/index.d.ts

@@ -0,0 +1,741 @@
+import { m as UseViewDataResult, n as UseActionResult, o as UseDataOptions, p as UseDataResult, T as Theme, a as DeviceType, P as Platform, S as SafeAreaInsets, D as DisplayMode, C as ContainerSize, I as InputCapabilities, q as UseCallToolResult, r as UseCallToolCallbacks, s as UseViewParamsResult, t as ActionStatus, A as ActionTool, u as AdaptorStoreKey, v as AdaptorStoreState, c as CallToolResult, w as CallToolStatus, d as ContentBlock, x as DataStatus, k as DataTool, E as ExternalStore, F as Feature, L as LogLevel, R as ResourceContent, f as ResourceReadResult, h as ResourceTeardownParams, j as TeardownHandler, e as ToolResponseMetadata, l as UnifiedAdaptor, U as UpdateModelContextParams, y as UseActionCallbacks, V as ViewDataStatus, z as ViewParamsStatus, g as getPlatform, i as isAppsSdkAvailable, b as isMcpAppsAvailable } from './adaptor-interface-BYbH9PpT.js';
+import { b as action, c as callTool, d as data, t as getAdaptor, i as isSupported, l as log, f as logDebug, j as logError, g as logInfo, h as logWarning, n as navigateToView, m as notifySizeChanged, k as onTeardown, o as openExternal, p as ping, e as readResource, r as requestDisplayMode, v as resetAdaptor, a as say, s as sendFollowUpMessage, q as setupAutoSizeReporting, u as updateModelContext } from './notify-size-changed-Ck2BGfUk.js';
+import React, { ReactNode } from 'react';
+import { T as ToolResultParams, U as UseHostStylesOptions, a as UseViewOptions, b as UseViewResult, V as View, c as ViewAppInfo, d as ViewOptions, e as createView, u as useDocumentTheme, f as useDocumentThemeState, g as useHostFontsHook, h as useHostStyles, i as useHostTheme, j as useHostVariables, k as useSystemColorScheme, l as useView } from './index-CpXDfXKD.js';
+import { S as StyleVariables, H as HostContext } from './types-B_O3kZYh.js';
+import { a as appsSdk } from './index-BBfZZJWn.js';
+import { m as mcpApps } from './index-DtukOUjY.js';
+
+/**
+ * Primary semantic hook for accessing view data (Tier 0)
+ *
+ * Combines tool input, output, and metadata into a single unified interface
+ * with status tracking for easy conditional rendering.
+ *
+ * @example
+ * ```tsx
+ * function MyView() {
+ *   const { status, input, output, isReady, isError, error } = useViewData<InputType, OutputType>();
+ *
+ *   if (status === 'idle') return <Loading />;
+ *   if (status === 'streaming') return <StreamingPreview partial={inputPartial} />;
+ *   if (status === 'pending') return <Processing />;
+ *   if (isError) return <Error message={error?.message} />;
+ *   if (isReady) return <Result data={output} />;
+ * }
+ * ```
+ */
+declare function useViewData<TInput = Record<string, unknown>, TOutput = unknown, TMeta = Record<string, unknown>>(): UseViewDataResult<TInput, TOutput, TMeta>;
+
+/**
+ * Hook for executing action tools (Tier 0 Semantic API)
+ *
+ * Actions are side-effect tools that mutate state. This hook provides
+ * status tracking and convenient execution methods.
+ *
+ * Use for: save, delete, update, navigate, send, submit
+ *
+ * @param toolName - Name of the action tool
+ * @returns Object with status, execute functions, and reset
+ *
+ * @example
+ * ```tsx
+ * function DeleteButton({ id }: { id: string }) {
+ *   const { isPending, isError, error, execute } = useAction<{ id: string }>('delete-item');
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         onClick={() => execute(
+ *           { id },
+ *           { onSuccess: () => console.log('Deleted!') }
+ *         )}
+ *         disabled={isPending}
+ *       >
+ *         {isPending ? 'Deleting...' : 'Delete'}
+ *       </button>
+ *       {isError && <p>Error: {error?.message}</p>}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useAction<TInput = void>(toolName: string): UseActionResult<TInput>;
+
+/**
+ * Hook for fetching data from tools (Tier 0 Semantic API)
+ *
+ * Data tools are read-only queries that return structured data. This hook
+ * provides status tracking, caching, and convenient fetch methods.
+ *
+ * Use for: search, get, list, fetch
+ *
+ * @param toolName - Name of the data tool
+ * @param defaultInput - Default input to use for fetches
+ * @param options - Configuration options
+ * @returns Object with status, data, fetch functions, and cache controls
+ *
+ * @example
+ * ```tsx
+ * function SearchResults({ query }: { query: string }) {
+ *   const { data, isPending, isStale, refetch } = useData<{ q: string }, Result[]>(
+ *     'search',
+ *     { q: query },
+ *     { staleTime: 30000, refetchOnWindowFocus: true }
+ *   );
+ *
+ *   return (
+ *     <div>
+ *       {isPending && <Loading />}
+ *       {isStale && <span>Refreshing...</span>}
+ *       {data?.map(item => <Item key={item.id} {...item} />)}
+ *       <button onClick={refetch}>Refresh</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useData<TInput = void, TOutput = unknown>(toolName: string, defaultInput?: TInput, options?: UseDataOptions<TOutput>): UseDataResult<TInput, TOutput>;
+
+/**
+ * Get the current theme (light or dark)
+ *
+ * @returns Current theme
+ *
+ * @example
+ * ```tsx
+ * function MyView() {
+ *   const theme = useTheme();
+ *   return <div className={theme === 'dark' ? 'dark' : 'light'}>...</div>;
+ * }
+ * ```
+ */
+declare function useTheme(): Theme;
+
+/**
+ * Get the user's locale setting
+ *
+ * @returns BCP 47 language tag (e.g., 'en-US')
+ */
+declare function useLocale(): string;
+
+/**
+ * Get the device type (mobile, tablet, desktop)
+ *
+ * @returns Device type
+ */
+declare function useDeviceType(): DeviceType;
+
+/**
+ * Get the current platform
+ *
+ * @returns Platform identifier
+ */
+declare function usePlatform(): Platform;
+
+/**
+ * Get safe area insets for devices with notches/rounded corners
+ *
+ * @returns Safe area insets object
+ */
+declare function useSafeArea(): SafeAreaInsets;
+
+/**
+ * Get the maximum height constraint
+ *
+ * @returns Maximum height in pixels
+ */
+declare function useMaxHeight(): number;
+
+/**
+ * Get the current display mode
+ *
+ * @returns Current display mode
+ */
+declare function useDisplayMode(): DisplayMode;
+
+/**
+ * Get the container size dimensions
+ *
+ * @returns Container size object with width and height
+ */
+declare function useContainerSize(): ContainerSize;
+
+/**
+ * Get input capabilities (keyboard, touch, etc.)
+ *
+ * @returns Input capabilities object
+ */
+declare function useInputCapabilities(): InputCapabilities;
+
+/**
+ * Get the tool input parameters
+ *
+ * @returns Tool input object or undefined
+ */
+declare function useToolInput<T = unknown>(): T | undefined;
+
+/**
+ * Get the tool output
+ *
+ * @returns Tool output object or undefined
+ */
+declare function useToolOutput<T = unknown>(): T | undefined;
+
+/**
+ * Get metadata about the tool response
+ *
+ * @returns Tool response metadata or undefined
+ */
+declare function useToolResponseMetadata<T = Record<string, unknown>>(): T | undefined;
+
+/**
+ * Options for the useCallTool hook (alias for UseCallToolCallbacks)
+ */
+type UseCallToolOptions<TOutput> = UseCallToolCallbacks<TOutput>;
+/**
+ * Rich hook for calling tools with full state machine
+ *
+ * @param toolName - Name of the tool to call
+ * @returns Object with status, data, error, and call functions
+ *
+ * @example
+ * ```tsx
+ * function SearchButton() {
+ *   const { isPending, isError, error, callTool } = useCallTool<
+ *     { query: string },
+ *     SearchResult
+ *   >('search');
+ *
+ *   return (
+ *     <>
+ *       <button
+ *         onClick={() => callTool(
+ *           { query: 'pancakes' },
+ *           { onSuccess: (data) => console.log('Found:', data) }
+ *         )}
+ *         disabled={isPending}
+ *       >
+ *         {isPending ? 'Searching...' : 'Search'}
+ *       </button>
+ *       {isError && <p>Error: {error?.message}</p>}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useCallTool<TInput = Record<string, unknown>, TOutput = unknown>(toolName: string): UseCallToolResult<TInput, TOutput>;
+
+/**
+ * Combined access to tool input/output with status derivation
+ *
+ * Status is derived as follows:
+ * - 'idle': No tool input received yet
+ * - 'pending': Tool input received, waiting for output
+ * - 'success': Both input and output available
+ *
+ * @returns Object with status flags and data
+ *
+ * @example
+ * ```tsx
+ * function SearchResults() {
+ *   const { status, isSuccess, input, output } = useViewParams<
+ *     { query: string },
+ *     SearchOutput,
+ *     { timing: number }
+ *   >();
+ *
+ *   if (!isSuccess) {
+ *     return <Loading query={input?.query} />;
+ *   }
+ *
+ *   return <ResultList results={output.items} />;
+ * }
+ * ```
+ */
+declare function useViewParams<TInput = Record<string, unknown>, TOutput = unknown, TMeta = Record<string, unknown>>(): UseViewParamsResult<TInput, TOutput, TMeta>;
+
+interface UseViewStateReturn<T> extends Array<T | ((newState: T | ((prev: T) => T)) => void)> {
+    /** Current state value */
+    0: T;
+    /** Function to update state */
+    1: (newState: T | ((prev: T) => T)) => void;
+    /** Current state value (named access) */
+    state: T;
+    /** Function to update state (named access) */
+    setState: (newState: T | ((prev: T) => T)) => void;
+    /** Reset state to initial value */
+    resetState: () => void;
+    /** Whether state differs from initial */
+    isDirty: boolean;
+}
+/**
+ * Manage view state with reset capability and dirty tracking.
+ * State is synced with the platform (persisted across conversation turns).
+ *
+ * Supports both tuple and object destructuring:
+ * @example
+ * ```tsx
+ * // Tuple style (like useState)
+ * const [count, setCount] = useViewState(0);
+ *
+ * // Object style (with extra features)
+ * const { state, setState, resetState, isDirty } = useViewState(0);
+ * ```
+ *
+ * @param initialState - Initial state value (used when no persisted state exists)
+ * @returns Tuple/object with state, setState, resetState, and isDirty flag
+ */
+declare function useViewState<T>(initialState: T): UseViewStateReturn<T>;
+
+interface HostEnvironment {
+    theme: Theme;
+    locale: string;
+    deviceType: DeviceType;
+    platform: Platform;
+    safeArea: SafeAreaInsets;
+    displayMode: DisplayMode;
+    containerSize: ContainerSize;
+    inputCapabilities: InputCapabilities;
+}
+/**
+ * Get all host environment information in a single hook
+ *
+ * @returns Complete host environment object
+ */
+declare function useHostEnvironment(): HostEnvironment;
+
+interface DisplayModeControl {
+    displayMode: DisplayMode;
+    requestFullscreen: () => Promise<void>;
+    requestInline: () => Promise<void>;
+    requestPip: () => Promise<void>;
+    requestDisplayMode: (mode: DisplayMode) => Promise<void>;
+    isFullscreen: boolean;
+    isInline: boolean;
+    isPip: boolean;
+}
+/**
+ * Control display mode with convenient methods
+ *
+ * @returns Display mode state and control methods
+ */
+declare function useDisplayModeControl(): DisplayModeControl;
+
+/**
+ * Check if the current device is mobile or tablet
+ *
+ * @returns true if deviceType is 'mobile' or 'tablet'
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const isMobile = useIsMobile();
+ *   return isMobile ? <MobileView /> : <DesktopView />;
+ * }
+ * ```
+ */
+declare function useIsMobile(): boolean;
+
+/**
+ * Check if the current display mode is fullscreen
+ *
+ * @returns true if displayMode is 'fullscreen'
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const isFullscreen = useIsFullscreen();
+ *   return isFullscreen ? <FullscreenLayout /> : <InlineLayout />;
+ * }
+ * ```
+ */
+declare function useIsFullscreen(): boolean;
+
+/**
+ * Check if the current theme is dark mode
+ *
+ * @returns true if theme is 'dark'
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const isDarkMode = useIsDarkMode();
+ *   return (
+ *     <div style={{ background: isDarkMode ? '#1a1a1a' : '#ffffff' }}>
+ *       Content
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useIsDarkMode(): boolean;
+
+interface PancakeContextValue {
+    isReady: boolean;
+    error: Error | undefined;
+    platform: 'apps-sdk' | 'mcp-apps';
+}
+interface PancakeProviderProps {
+    /**
+     * Children to render once the provider is ready
+     */
+    children: ReactNode;
+    /**
+     * Callback when initialization fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Enable debug logging
+     */
+    debug?: boolean;
+    /**
+     * Custom loading component to show while initializing (MCP only)
+     * If not provided, children are rendered immediately on Apps SDK,
+     * and nothing is rendered until ready on MCP
+     */
+    fallback?: ReactNode;
+    /**
+     * If true, renders children even before initialization completes
+     * Use this for progressive enhancement patterns
+     */
+    immediate?: boolean;
+}
+/**
+ * Provider component that handles platform initialization
+ *
+ * On MCP Apps: Waits for handshake to complete before rendering children
+ * On Apps SDK: Renders immediately (no async initialization needed)
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   return (
+ *     <PancakeProvider
+ *       onError={(e) => console.error('Init failed:', e)}
+ *       fallback={<LoadingSpinner />}
+ *     >
+ *       <MyPancakeApp />
+ *     </PancakeProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function PancakeProvider({ children, onError, debug, fallback, immediate, }: PancakeProviderProps): React.ReactElement | null;
+/**
+ * Hook to access Pancake provider context
+ *
+ * @returns Context value with isReady, error, and platform
+ * @throws If used outside of PancakeProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { isReady, platform, error } = usePancakeContext();
+ *   if (error) return <Error error={error} />;
+ *   if (!isReady) return <Loading />;
+ *   return <Content />;
+ * }
+ * ```
+ */
+declare function usePancakeContext(): PancakeContextValue;
+
+/**
+ * Development Mode Helpers
+ *
+ * Utilities for debugging and development environments.
+ */
+/**
+ * Check if running in development mode
+ */
+declare const DEBUG: boolean;
+/**
+ * Check if running in a test environment
+ */
+declare const IS_TEST: boolean;
+/**
+ * Check if running in Storybook
+ */
+declare const IS_STORYBOOK: boolean;
+/**
+ * Log a debug message (only in development mode)
+ *
+ * @param message - Message to log
+ * @param data - Optional data to log
+ */
+declare function debugLog(message: string, data?: unknown): void;
+/**
+ * Log a debug warning (only in development mode)
+ *
+ * @param message - Warning message
+ * @param data - Optional data to log
+ */
+declare function debugWarn(message: string, data?: unknown): void;
+/**
+ * Assert a condition and log an error if it fails (development only)
+ *
+ * @param condition - Condition to check
+ * @param message - Error message if condition is false
+ */
+declare function debugAssert(condition: boolean, message: string): void;
+/**
+ * Measure execution time of a function (development only)
+ *
+ * @param label - Label for the measurement
+ * @param fn - Function to measure
+ * @returns Result of the function
+ */
+declare function debugTime<T>(label: string, fn: () => T): T;
+/**
+ * Async version of debugTime
+ *
+ * @param label - Label for the measurement
+ * @param fn - Async function to measure
+ * @returns Promise with result of the function
+ */
+declare function debugTimeAsync<T>(label: string, fn: () => Promise<T>): Promise<T>;
+
+/**
+ * Style Utilities
+ *
+ * Standalone utility functions for theming and styling.
+ * These work anywhere without requiring React or adaptors.
+ *
+ * @example
+ * ```typescript
+ * import { getDocumentTheme, applyDocumentTheme, applyHostStyleVariables } from '@pancake-apps/web';
+ *
+ * // Detect current theme
+ * const theme = getDocumentTheme();
+ *
+ * // Apply theme to document
+ * applyDocumentTheme('dark');
+ *
+ * // Apply host-provided CSS variables
+ * applyHostStyleVariables({
+ *   '--color-background-primary': '#ffffff',
+ *   '--color-text-primary': '#000000',
+ * });
+ * ```
+ */
+
+/**
+ * Detect the current document theme based on:
+ * 1. Document color scheme meta tag
+ * 2. Media query preference
+ * 3. Document class (dark/light)
+ */
+declare function getDocumentTheme(): Theme;
+/**
+ * Create a reactive theme detection observer
+ * Returns current theme and calls callback on changes
+ */
+declare function observeDocumentTheme(callback: (theme: Theme) => void): {
+    getTheme: () => Theme;
+    disconnect: () => void;
+};
+/**
+ * Apply a theme to the document
+ * Sets both the class and data-theme attribute
+ */
+declare function applyDocumentTheme(theme: Theme): void;
+/**
+ * Apply host-provided CSS variables to the document
+ */
+declare function applyHostStyleVariables(variables: StyleVariables | Record<string, string>): void;
+/**
+ * Apply host-provided font CSS
+ */
+declare function applyHostFonts(css: string): void;
+/**
+ * Remove all host-applied styles
+ */
+declare function clearHostStyles(): void;
+/**
+ * Apply all styles from a HostContext
+ * Includes theme, CSS variables, and fonts
+ */
+declare function applyHostContext(context: HostContext): void;
+/**
+ * Extract CSS variables currently applied to an element
+ */
+declare function getComputedStyleVariables(element?: HTMLElement, variableNames?: string[]): Record<string, string>;
+/**
+ * Apply safe area insets as CSS variables
+ */
+declare function applySafeAreaInsets(insets: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}): void;
+/**
+ * Get the current safe area insets from CSS environment variables
+ */
+declare function getSafeAreaInsets(): {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+
+declare const unified_ActionStatus: typeof ActionStatus;
+declare const unified_ActionTool: typeof ActionTool;
+declare const unified_AdaptorStoreKey: typeof AdaptorStoreKey;
+declare const unified_AdaptorStoreState: typeof AdaptorStoreState;
+declare const unified_CallToolResult: typeof CallToolResult;
+declare const unified_CallToolStatus: typeof CallToolStatus;
+declare const unified_ContainerSize: typeof ContainerSize;
+declare const unified_ContentBlock: typeof ContentBlock;
+declare const unified_DEBUG: typeof DEBUG;
+declare const unified_DataStatus: typeof DataStatus;
+declare const unified_DataTool: typeof DataTool;
+declare const unified_DeviceType: typeof DeviceType;
+declare const unified_DisplayMode: typeof DisplayMode;
+type unified_DisplayModeControl = DisplayModeControl;
+declare const unified_ExternalStore: typeof ExternalStore;
+declare const unified_Feature: typeof Feature;
+type unified_HostEnvironment = HostEnvironment;
+declare const unified_IS_STORYBOOK: typeof IS_STORYBOOK;
+declare const unified_IS_TEST: typeof IS_TEST;
+declare const unified_InputCapabilities: typeof InputCapabilities;
+declare const unified_LogLevel: typeof LogLevel;
+declare const unified_PancakeProvider: typeof PancakeProvider;
+type unified_PancakeProviderProps = PancakeProviderProps;
+declare const unified_Platform: typeof Platform;
+declare const unified_ResourceContent: typeof ResourceContent;
+declare const unified_ResourceReadResult: typeof ResourceReadResult;
+declare const unified_ResourceTeardownParams: typeof ResourceTeardownParams;
+declare const unified_SafeAreaInsets: typeof SafeAreaInsets;
+declare const unified_TeardownHandler: typeof TeardownHandler;
+declare const unified_Theme: typeof Theme;
+declare const unified_ToolResponseMetadata: typeof ToolResponseMetadata;
+declare const unified_ToolResultParams: typeof ToolResultParams;
+declare const unified_UnifiedAdaptor: typeof UnifiedAdaptor;
+declare const unified_UpdateModelContextParams: typeof UpdateModelContextParams;
+declare const unified_UseActionCallbacks: typeof UseActionCallbacks;
+declare const unified_UseActionResult: typeof UseActionResult;
+declare const unified_UseCallToolCallbacks: typeof UseCallToolCallbacks;
+type unified_UseCallToolOptions<TOutput> = UseCallToolOptions<TOutput>;
+declare const unified_UseCallToolResult: typeof UseCallToolResult;
+declare const unified_UseDataOptions: typeof UseDataOptions;
+declare const unified_UseDataResult: typeof UseDataResult;
+declare const unified_UseHostStylesOptions: typeof UseHostStylesOptions;
+declare const unified_UseViewDataResult: typeof UseViewDataResult;
+declare const unified_UseViewOptions: typeof UseViewOptions;
+declare const unified_UseViewParamsResult: typeof UseViewParamsResult;
+declare const unified_UseViewResult: typeof UseViewResult;
+type unified_UseViewStateReturn<T> = UseViewStateReturn<T>;
+declare const unified_View: typeof View;
+declare const unified_ViewAppInfo: typeof ViewAppInfo;
+declare const unified_ViewDataStatus: typeof ViewDataStatus;
+declare const unified_ViewOptions: typeof ViewOptions;
+declare const unified_ViewParamsStatus: typeof ViewParamsStatus;
+declare const unified_action: typeof action;
+declare const unified_applyDocumentTheme: typeof applyDocumentTheme;
+declare const unified_applyHostContext: typeof applyHostContext;
+declare const unified_applyHostFonts: typeof applyHostFonts;
+declare const unified_applyHostStyleVariables: typeof applyHostStyleVariables;
+declare const unified_applySafeAreaInsets: typeof applySafeAreaInsets;
+declare const unified_callTool: typeof callTool;
+declare const unified_clearHostStyles: typeof clearHostStyles;
+declare const unified_createView: typeof createView;
+declare const unified_data: typeof data;
+declare const unified_debugAssert: typeof debugAssert;
+declare const unified_debugLog: typeof debugLog;
+declare const unified_debugTime: typeof debugTime;
+declare const unified_debugTimeAsync: typeof debugTimeAsync;
+declare const unified_debugWarn: typeof debugWarn;
+declare const unified_getAdaptor: typeof getAdaptor;
+declare const unified_getComputedStyleVariables: typeof getComputedStyleVariables;
+declare const unified_getDocumentTheme: typeof getDocumentTheme;
+declare const unified_getPlatform: typeof getPlatform;
+declare const unified_getSafeAreaInsets: typeof getSafeAreaInsets;
+declare const unified_isAppsSdkAvailable: typeof isAppsSdkAvailable;
+declare const unified_isMcpAppsAvailable: typeof isMcpAppsAvailable;
+declare const unified_isSupported: typeof isSupported;
+declare const unified_log: typeof log;
+declare const unified_logDebug: typeof logDebug;
+declare const unified_logError: typeof logError;
+declare const unified_logInfo: typeof logInfo;
+declare const unified_logWarning: typeof logWarning;
+declare const unified_navigateToView: typeof navigateToView;
+declare const unified_notifySizeChanged: typeof notifySizeChanged;
+declare const unified_observeDocumentTheme: typeof observeDocumentTheme;
+declare const unified_onTeardown: typeof onTeardown;
+declare const unified_openExternal: typeof openExternal;
+declare const unified_ping: typeof ping;
+declare const unified_readResource: typeof readResource;
+declare const unified_requestDisplayMode: typeof requestDisplayMode;
+declare const unified_resetAdaptor: typeof resetAdaptor;
+declare const unified_say: typeof say;
+declare const unified_sendFollowUpMessage: typeof sendFollowUpMessage;
+declare const unified_setupAutoSizeReporting: typeof setupAutoSizeReporting;
+declare const unified_updateModelContext: typeof updateModelContext;
+declare const unified_useAction: typeof useAction;
+declare const unified_useCallTool: typeof useCallTool;
+declare const unified_useContainerSize: typeof useContainerSize;
+declare const unified_useData: typeof useData;
+declare const unified_useDeviceType: typeof useDeviceType;
+declare const unified_useDisplayMode: typeof useDisplayMode;
+declare const unified_useDisplayModeControl: typeof useDisplayModeControl;
+declare const unified_useDocumentTheme: typeof useDocumentTheme;
+declare const unified_useDocumentThemeState: typeof useDocumentThemeState;
+declare const unified_useHostEnvironment: typeof useHostEnvironment;
+declare const unified_useHostFontsHook: typeof useHostFontsHook;
+declare const unified_useHostStyles: typeof useHostStyles;
+declare const unified_useHostTheme: typeof useHostTheme;
+declare const unified_useHostVariables: typeof useHostVariables;
+declare const unified_useInputCapabilities: typeof useInputCapabilities;
+declare const unified_useIsDarkMode: typeof useIsDarkMode;
+declare const unified_useIsFullscreen: typeof useIsFullscreen;
+declare const unified_useIsMobile: typeof useIsMobile;
+declare const unified_useLocale: typeof useLocale;
+declare const unified_useMaxHeight: typeof useMaxHeight;
+declare const unified_usePancakeContext: typeof usePancakeContext;
+declare const unified_usePlatform: typeof usePlatform;
+declare const unified_useSafeArea: typeof useSafeArea;
+declare const unified_useSystemColorScheme: typeof useSystemColorScheme;
+declare const unified_useTheme: typeof useTheme;
+declare const unified_useToolInput: typeof useToolInput;
+declare const unified_useToolOutput: typeof useToolOutput;
+declare const unified_useToolResponseMetadata: typeof useToolResponseMetadata;
+declare const unified_useView: typeof useView;
+declare const unified_useViewData: typeof useViewData;
+declare const unified_useViewParams: typeof useViewParams;
+declare const unified_useViewState: typeof useViewState;
+declare namespace unified {
+  export { unified_ActionStatus as ActionStatus, unified_ActionTool as ActionTool, unified_AdaptorStoreKey as AdaptorStoreKey, unified_AdaptorStoreState as AdaptorStoreState, unified_CallToolResult as CallToolResult, unified_CallToolStatus as CallToolStatus, unified_ContainerSize as ContainerSize, unified_ContentBlock as ContentBlock, unified_DEBUG as DEBUG, unified_DataStatus as DataStatus, unified_DataTool as DataTool, unified_DeviceType as DeviceType, unified_DisplayMode as DisplayMode, type unified_DisplayModeControl as DisplayModeControl, unified_ExternalStore as ExternalStore, unified_Feature as Feature, type unified_HostEnvironment as HostEnvironment, unified_IS_STORYBOOK as IS_STORYBOOK, unified_IS_TEST as IS_TEST, unified_InputCapabilities as InputCapabilities, unified_LogLevel as LogLevel, unified_PancakeProvider as PancakeProvider, type unified_PancakeProviderProps as PancakeProviderProps, unified_Platform as Platform, unified_ResourceContent as ResourceContent, unified_ResourceReadResult as ResourceReadResult, unified_ResourceTeardownParams as ResourceTeardownParams, unified_SafeAreaInsets as SafeAreaInsets, unified_TeardownHandler as TeardownHandler, unified_Theme as Theme, unified_ToolResponseMetadata as ToolResponseMetadata, unified_ToolResultParams as ToolResultParams, unified_UnifiedAdaptor as UnifiedAdaptor, unified_UpdateModelContextParams as UpdateModelContextParams, unified_UseActionCallbacks as UseActionCallbacks, unified_UseActionResult as UseActionResult, unified_UseCallToolCallbacks as UseCallToolCallbacks, type unified_UseCallToolOptions as UseCallToolOptions, unified_UseCallToolResult as UseCallToolResult, unified_UseDataOptions as UseDataOptions, unified_UseDataResult as UseDataResult, unified_UseHostStylesOptions as UseHostStylesOptions, unified_UseViewDataResult as UseViewDataResult, unified_UseViewOptions as UseViewOptions, unified_UseViewParamsResult as UseViewParamsResult, unified_UseViewResult as UseViewResult, type unified_UseViewStateReturn as UseViewStateReturn, unified_View as View, unified_ViewAppInfo as ViewAppInfo, unified_ViewDataStatus as ViewDataStatus, unified_ViewOptions as ViewOptions, unified_ViewParamsStatus as ViewParamsStatus, unified_action as action, unified_applyDocumentTheme as applyDocumentTheme, unified_applyHostContext as applyHostContext, unified_applyHostFonts as applyHostFonts, unified_applyHostStyleVariables as applyHostStyleVariables, unified_applySafeAreaInsets as applySafeAreaInsets, unified_callTool as callTool, unified_clearHostStyles as clearHostStyles, unified_createView as createView, unified_data as data, unified_debugAssert as debugAssert, unified_debugLog as debugLog, unified_debugTime as debugTime, unified_debugTimeAsync as debugTimeAsync, unified_debugWarn as debugWarn, unified_getAdaptor as getAdaptor, unified_getComputedStyleVariables as getComputedStyleVariables, unified_getDocumentTheme as getDocumentTheme, unified_getPlatform as getPlatform, unified_getSafeAreaInsets as getSafeAreaInsets, unified_isAppsSdkAvailable as isAppsSdkAvailable, unified_isMcpAppsAvailable as isMcpAppsAvailable, unified_isSupported as isSupported, unified_log as log, unified_logDebug as logDebug, unified_logError as logError, unified_logInfo as logInfo, unified_logWarning as logWarning, unified_navigateToView as navigateToView, unified_notifySizeChanged as notifySizeChanged, unified_observeDocumentTheme as observeDocumentTheme, unified_onTeardown as onTeardown, unified_openExternal as openExternal, unified_ping as ping, unified_readResource as readResource, unified_requestDisplayMode as requestDisplayMode, unified_resetAdaptor as resetAdaptor, unified_say as say, unified_sendFollowUpMessage as sendFollowUpMessage, unified_setupAutoSizeReporting as setupAutoSizeReporting, unified_updateModelContext as updateModelContext, unified_useAction as useAction, unified_useCallTool as useCallTool, unified_useContainerSize as useContainerSize, unified_useData as useData, unified_useDeviceType as useDeviceType, unified_useDisplayMode as useDisplayMode, unified_useDisplayModeControl as useDisplayModeControl, unified_useDocumentTheme as useDocumentTheme, unified_useDocumentThemeState as useDocumentThemeState, unified_useHostEnvironment as useHostEnvironment, unified_useHostFontsHook as useHostFontsHook, unified_useHostStyles as useHostStyles, unified_useHostTheme as useHostTheme, unified_useHostVariables as useHostVariables, unified_useInputCapabilities as useInputCapabilities, unified_useIsDarkMode as useIsDarkMode, unified_useIsFullscreen as useIsFullscreen, unified_useIsMobile as useIsMobile, unified_useLocale as useLocale, unified_useMaxHeight as useMaxHeight, unified_usePancakeContext as usePancakeContext, unified_usePlatform as usePlatform, unified_useSafeArea as useSafeArea, unified_useSystemColorScheme as useSystemColorScheme, unified_useTheme as useTheme, unified_useToolInput as useToolInput, unified_useToolOutput as useToolOutput, unified_useToolResponseMetadata as useToolResponseMetadata, unified_useView as useView, unified_useViewData as useViewData, unified_useViewParams as useViewParams, unified_useViewState as useViewState };
+}
+
+/**
+ * @pancake-apps/web - Unified SDK for building Pancake apps
+ *
+ * This is the main entry point that auto-detects the platform
+ * and provides a unified API.
+ *
+ * Subpath exports:
+ * - @pancake-apps/web - Unified SDK (this file)
+ * - @pancake-apps/web/apps-sdk - ChatGPT Apps SDK
+ * - @pancake-apps/web/mcp-apps - MCP Apps SDK
+ */
+
+declare global {
+    interface Window {
+        pancake?: PancakeGlobal;
+    }
+}
+interface PancakeGlobal {
+    platform: ReturnType<typeof getPlatform>;
+    adaptor: ReturnType<typeof getAdaptor>;
+    appsSdk: typeof appsSdk;
+    mcpApps: typeof mcpApps;
+    unified: typeof unified;
+}
+/**
+ * Initialize and attach the pancake global object to window
+ * This allows imperative access to the SDK from non-React code
+ */
+declare function initPancake(): PancakeGlobal;
+
+export { ActionStatus, ActionTool, AdaptorStoreKey, AdaptorStoreState, CallToolResult, CallToolStatus, ContainerSize, ContentBlock, DEBUG, DataStatus, DataTool, DeviceType, DisplayMode, type DisplayModeControl, ExternalStore, Feature, type HostEnvironment, IS_STORYBOOK, IS_TEST, InputCapabilities, LogLevel, type PancakeGlobal, PancakeProvider, type PancakeProviderProps, Platform, ResourceContent, ResourceReadResult, ResourceTeardownParams, SafeAreaInsets, TeardownHandler, Theme, ToolResponseMetadata, ToolResultParams, UnifiedAdaptor, UpdateModelContextParams, UseActionCallbacks, UseActionResult, UseCallToolCallbacks, type UseCallToolOptions, UseCallToolResult, UseDataOptions, UseDataResult, UseHostStylesOptions, UseViewDataResult, UseViewOptions, UseViewParamsResult, UseViewResult, type UseViewStateReturn, View, ViewAppInfo, ViewDataStatus, ViewOptions, ViewParamsStatus, action, applyDocumentTheme, applyHostContext, applyHostFonts, applyHostStyleVariables, applySafeAreaInsets, appsSdk, callTool, clearHostStyles, createView, data, debugAssert, debugLog, debugTime, debugTimeAsync, debugWarn, getAdaptor, getComputedStyleVariables, getDocumentTheme, getPlatform, getSafeAreaInsets, initPancake, isAppsSdkAvailable, isMcpAppsAvailable, isSupported, log, logDebug, logError, logInfo, logWarning, mcpApps, navigateToView, notifySizeChanged, observeDocumentTheme, onTeardown, openExternal, ping, readResource, requestDisplayMode, resetAdaptor, say, sendFollowUpMessage, setupAutoSizeReporting, updateModelContext, useAction, useCallTool, useContainerSize, useData, useDeviceType, useDisplayMode, useDisplayModeControl, useDocumentTheme, useDocumentThemeState, useHostEnvironment, useHostFontsHook, useHostStyles, useHostTheme, useHostVariables, useInputCapabilities, useIsDarkMode, useIsFullscreen, useIsMobile, useLocale, useMaxHeight, usePancakeContext, usePlatform, useSafeArea, useSystemColorScheme, useTheme, useToolInput, useToolOutput, useToolResponseMetadata, useView, useViewData, useViewParams, useViewState };