sunpeak 0.1.22 → 0.2.2

package/dist/index.d.ts

@@ -1,245 +1,19 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
-import { HTMLAttributes, ReactNode, SetStateAction } from 'react';
-import * as _mui_material from '@mui/material';
-import { ButtonProps as ButtonProps$1 } from '@mui/material';
-import { ThemeOptions, Theme as Theme$2 } from '@mui/material/styles';
-
-interface GenAIProps extends HTMLAttributes<HTMLDivElement> {
-    /**
-     * Maximum width in pixels
-     * @default 800
-     */
-    maxWidth?: number;
-    /**
-     * Override the color scheme detection
-     * If not provided, uses window.openai.colorScheme
-     */
-    mode?: 'light' | 'dark';
-    /**
-     * Whether to inject MUI's CssBaseline component
-     * @default true
-     */
-    enableCssBaseline?: boolean;
-}
-interface GenAIRenderProps {
-    /**
-     * Maximum height from platform (in pixels)
-     */
-    maxHeight: number | null;
-    /**
-     * Color scheme from platform
-     */
-    colorScheme: 'light' | 'dark' | null;
-}
-/**
- * GenAI - Create platform-aware genAI Apps with automatic theming and constraints.
- *
- * This is the single interface for building genAI Apps. It automatically provides:
- * - MUI theming (light/dark mode from platform)
- * - Platform constraints (maxHeight)
- * - Color scheme information
- *
- * @example
- * ```tsx
- * export const MyApp = GenAI(({ maxHeight, colorScheme }) => (
- *   <div>
- *     <h2>My App</h2>
- *     <p>Theme: {colorScheme}</p>
- *     <p>Max height: {maxHeight}px</p>
- *   </div>
- * ));
- * ```
- */
-declare function GenAI(renderFn: (props: GenAIRenderProps) => ReactNode): {
-    (props?: GenAIProps): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-
-interface ButtonProps extends Omit<ButtonProps$1, 'onClick'> {
-    /**
-     * Whether to use primary styling (accent color) or secondary (outlined)
-     */
-    isPrimary?: boolean;
-    /**
-     * Click handler (required)
-     */
-    onClick: () => void;
-}
-interface CardProps extends Omit<GenAIProps, 'children'>, HTMLAttributes<HTMLDivElement> {
-    /**
-     * Card content
-     */
-    children?: ReactNode;
-    /**
-     * Image to display at the top of the card
-     */
-    image: string;
-    /**
-     * Alt text for the image
-     */
-    imageAlt: string;
-    /**
-     * Maximum width for the image in pixels
-     */
-    imageMaxWidth: number;
-    /**
-     * Maximum height for the image in pixels
-     */
-    imageMaxHeight: number;
-    /**
-     * Optional header text (title)
-     */
-    header?: ReactNode;
-    /**
-     * Optional metadata text (e.g., rating, category)
-     */
-    metadata?: ReactNode;
-    /**
-     * First action button (0-1)
-     */
-    button1?: ButtonProps;
-    /**
-     * Second action button (0-1)
-     */
-    button2?: ButtonProps;
-    /**
-     * Card variant
-     */
-    variant?: 'default' | 'bordered' | 'elevated';
-}
-/**
- * Card - A responsive card component that adapts to display mode.
- *
- * In inline mode:
- * - Fixed width for carousel consistency
- * - Compact layout optimized for horizontal scrolling
- * - Clickable to request fullscreen mode
- *
- * In fullscreen mode:
- * - Full width layout
- * - Expanded content display
- * - More breathing room for content
- *
- * Design specs:
- * - Image: aspect-square with 24px border radius
- * - Typography: 16px medium for header, 12px for metadata, 14px for description
- * - Spacing: 12px between sections
- * - Max 2 actions in footer (design guideline)
- */
-declare const Card: ({ children, image, imageAlt, imageMaxWidth, imageMaxHeight, header, metadata, button1, button2, variant, className, onClick, id, ...props }: CardProps) => react_jsx_runtime.JSX.Element;
-
-interface CarouselProps extends Omit<GenAIProps, 'children'>, HTMLAttributes<HTMLDivElement> {
-    /**
-     * Carousel items (typically Card components)
-     */
-    children: ReactNode;
-    /**
-     * Gap between items in pixels
-     * @default 16
-     */
-    gap?: number;
-    /**
-     * Show navigation arrows
-     * @default true
-     */
-    showArrows?: boolean;
-    /**
-     * Show edge gradients to indicate more content
-     * @default true
-     */
-    showEdgeGradients?: boolean;
-}
-/**
- * Carousel - MUI-based carousel for displaying cards side-by-side.
- * Follows OpenAI ChatGPT Apps SDK design guidelines.
- */
-declare const Carousel: ({ children, gap, maxWidth, showArrows, showEdgeGradients, className, ...props }: CarouselProps) => react_jsx_runtime.JSX.Element;
-
-type UnknownObject$1 = Record<string, unknown>;
-type Theme$1 = 'light' | 'dark';
-type SafeAreaInsets$1 = {
-    top: number;
-    bottom: number;
-    left: number;
-    right: number;
+import * as React from 'react';
+import { ClassValue } from 'clsx';
+
+type Theme$1 = "light" | "dark";
+type ThemeProviderProps = {
+    children: React.ReactNode;
+    defaultTheme?: Theme$1;
+    theme?: Theme$1;
 };
-type SafeArea$1 = {
-    insets: SafeAreaInsets$1;
+type ThemeProviderState = {
+    theme: Theme$1;
 };
-type DeviceType$1 = 'mobile' | 'tablet' | 'desktop' | 'unknown';
-type UserAgent$1 = {
-    device: {
-        type: DeviceType$1;
-    };
-    capabilities: {
-        hover: boolean;
-        touch: boolean;
-    };
-};
-/** Display mode */
-type DisplayMode$1 = 'pip' | 'inline' | 'fullscreen';
-type RequestDisplayMode$1 = (args: {
-    mode: DisplayMode$1;
-}) => Promise<{
-    /**
-     * The granted display mode. The host may reject the request.
-     * For mobile, PiP is always coerced to fullscreen.
-     */
-    mode: DisplayMode$1;
-}>;
-type CallToolResponse$1 = {
-    result: string;
-};
-/** Calling APIs */
-type CallTool$1 = (name: string, args: Record<string, unknown>) => Promise<CallToolResponse$1>;
-type ChatGPTGlobals<ToolInput = UnknownObject$1, ToolOutput = UnknownObject$1, ToolResponseMetadata = UnknownObject$1, WidgetState = UnknownObject$1> = {
-    colorScheme: Theme$1;
-    userAgent: UserAgent$1;
-    locale: string;
-    maxHeight: number;
-    displayMode: DisplayMode$1;
-    safeArea: SafeArea$1;
-    toolInput: ToolInput;
-    toolOutput: ToolOutput | null;
-    toolResponseMetadata: ToolResponseMetadata | null;
-    widgetState: WidgetState | null;
-    setWidgetState: (state: WidgetState) => Promise<void>;
-};
-type API = {
-    callTool: CallTool$1;
-    sendFollowUpMessage: (args: {
-        prompt: string;
-    }) => Promise<void>;
-    openExternal(payload: {
-        href: string;
-    }): void;
-    requestDisplayMode: RequestDisplayMode$1;
-};
-/** Extra events */
-declare const SET_GLOBALS_EVENT_TYPE = "chatgpt:set_globals";
-declare class SetGlobalsEvent extends CustomEvent<{
-    globals: Partial<ChatGPTGlobals>;
-}> {
-    readonly type = "chatgpt:set_globals";
-}
-/**
- * Global openai object injected by the web sandbox for communicating with ChatGPT host page.
- */
-declare global {
-    interface Window {
-        openai?: API & ChatGPTGlobals;
-    }
-    interface WindowEventMap {
-        [SET_GLOBALS_EVENT_TYPE]: SetGlobalsEvent;
-    }
-}
+declare function ThemeProvider({ children, defaultTheme, theme: controlledTheme, ...props }: ThemeProviderProps): react_jsx_runtime.JSX.Element;
+declare const useThemeContext: () => ThemeProviderState;
 
-/**
- * Platform-agnostic types for genAI App SDKs
- *
- * These types define a common interface that can be implemented
- * by different platforms (ChatGPT, Gemini, Claude, etc.)
- */
 type UnknownObject = Record<string, unknown>;
 type Theme = 'light' | 'dark';
 type SafeAreaInsets = {
@@ -261,7 +35,6 @@ type UserAgent = {
         touch: boolean;
     };
 };
-/** Display mode for the app */
 type DisplayMode = 'pip' | 'inline' | 'fullscreen';
 type RequestDisplayMode = (args: {
     mode: DisplayMode;
@@ -272,13 +45,8 @@ type CallToolResponse = {
     result: string;
 };
 type CallTool = (name: string, args: Record<string, unknown>) => Promise<CallToolResponse>;
-/**
- * Platform-agnostic global state interface
- *
- * All genAI platforms should implement this interface to work with Sunpeak components.
- */
-type PlatformGlobals<ToolInput = UnknownObject, ToolOutput = UnknownObject, ToolResponseMetadata = UnknownObject, WidgetState = UnknownObject> = {
-    colorScheme: Theme;
+type OpenAiGlobals<ToolInput = UnknownObject, ToolOutput = UnknownObject, ToolResponseMetadata = UnknownObject, WidgetState = UnknownObject> = {
+    theme: Theme;
     userAgent: UserAgent;
     locale: string;
     maxHeight: number;
@@ -290,10 +58,7 @@ type PlatformGlobals<ToolInput = UnknownObject, ToolOutput = UnknownObject, Tool
     widgetState: WidgetState | null;
     setWidgetState: (state: WidgetState) => Promise<void>;
 };
-/**
- * Platform API methods
- */
-type PlatformAPI = {
+type OpenAiAPI = {
     callTool: CallTool;
     sendFollowUpMessage: (args: {
         prompt: string;
@@ -303,347 +68,99 @@ type PlatformAPI = {
     }): void;
     requestDisplayMode: RequestDisplayMode;
 };
-/**
- * Platform adapter interface
- *
- * Implement this interface to add support for a new genAI platform.
- */
-interface PlatformAdapter {
-    /**
-     * Platform identifier (e.g., 'chatgpt', 'gemini', 'claude')
-     */
-    readonly name: string;
-    /**
-     * Check if this platform is available in the current environment
-     */
-    isAvailable(): boolean;
-    /**
-     * Get a specific global value
-     */
-    getGlobal<K extends keyof PlatformGlobals>(key: K): PlatformGlobals[K] | null;
-    /**
-     * Get all platform globals
-     */
-    getGlobals(): (PlatformAPI & PlatformGlobals) | null;
-    /**
-     * Subscribe to changes in platform globals
-     * Returns an unsubscribe function
-     */
-    subscribe(callback: () => void): () => void;
-}
-/**
- * Platform registry to track supported platforms
- */
-type PlatformType = 'chatgpt' | 'gemini' | 'claude' | 'custom';
-
-interface ChatGPTSimulatorProps {
-    /**
-     * The component to render in the ChatGPT message
-     * Can be a function that receives the selected App UI
-     */
-    children: ReactNode | ((uiSimulation: string) => ReactNode);
-    /**
-     * Initial display mode
-     */
-    displayMode?: DisplayMode$1;
-    /**
-     * Initial color scheme
-     */
-    colorScheme?: Theme$1;
-    /**
-     * Initial tool input
-     */
-    toolInput?: Record<string, unknown>;
-    /**
-     * Initial tool output
-     */
-    toolOutput?: Record<string, unknown> | null;
-    /**
-     * Initial widget state
-     */
-    widgetState?: Record<string, unknown> | null;
-    /**
-     * User message to display above the component
-     */
-    userMessage?: string;
-    /**
-     * Show simulator controls
-     */
-    showControls?: boolean;
-    /**
-     * App UIs for the App UI selector
-     */
-    uiSimulations?: string[];
-    /**
-     * Initial App UI
-     */
-    initialUISimulation?: string;
-}
-/**
- * ChatGPT Simulator Component
- *
- * Emulates the ChatGPT environment for testing components locally.
- * Provides window.openai API and renders components in a ChatGPT-like UI.
- */
-declare function ChatGPTSimulator({ children, displayMode: initialDisplayMode, colorScheme: initialColorScheme, toolInput, toolOutput, widgetState: initialWidgetState, userMessage, showControls, uiSimulations, initialUISimulation, }: ChatGPTSimulatorProps): react_jsx_runtime.JSX.Element;
-
-interface PlatformProviderProps {
-    /**
-     * The platform adapter to use. If not provided, will auto-detect.
-     */
-    adapter?: PlatformAdapter;
-    /**
-     * Platform name to use (e.g., 'chatgpt', 'gemini'). If not provided, will auto-detect.
-     */
-    platform?: string;
-    children: ReactNode;
-}
-/**
- * Platform Provider
- *
- * Wrap your app with this provider to specify which genAI platform to use.
- * If no platform is specified, it will auto-detect the available platform.
- *
- * @example
- * ```tsx
- * import { PlatformProvider } from 'sunpeak';
- *
- * // Auto-detect platform
- * <PlatformProvider>
- *   <App />
- * </PlatformProvider>
- *
- * // Explicitly use ChatGPT
- * <PlatformProvider platform="chatgpt">
- *   <App />
- * </PlatformProvider>
- * ```
- */
-declare function PlatformProvider({ adapter, platform, children }: PlatformProviderProps): react_jsx_runtime.JSX.Element;
-/**
- * Hook to access the current platform adapter
- *
- * Returns null if no platform is available or detected.
- */
-declare function usePlatform(): PlatformAdapter | null;
-
-declare class ChatGPTPlatformAdapter implements PlatformAdapter {
-    readonly name = "chatgpt";
-    isAvailable(): boolean;
-    getGlobal<K extends keyof PlatformGlobals>(key: K): PlatformGlobals[K] | null;
-    getGlobals(): ({
-        callTool: CallTool$1;
-        sendFollowUpMessage: (args: {
-            prompt: string;
-        }) => Promise<void>;
-        openExternal(payload: {
-            href: string;
-        }): void;
-        requestDisplayMode: RequestDisplayMode$1;
-    } & ChatGPTGlobals<UnknownObject$1, UnknownObject$1, UnknownObject$1, UnknownObject$1>) | null;
-    subscribe(callback: () => void): () => void;
+declare const SET_GLOBALS_EVENT_TYPE = "openai:set_globals";
+declare class SetGlobalsEvent extends CustomEvent<{
+    globals: Partial<OpenAiGlobals>;
+}> {
+    readonly type = "openai:set_globals";
 }
-/**
- * Singleton instance of the ChatGPT platform adapter
- */
-declare const chatgptPlatform: ChatGPTPlatformAdapter;
-
-/**
- * Platform Registry
- *
- * Manages multiple platform adapters and auto-detects the active platform.
- */
-
-interface PlatformRegistry {
-    /**
-     * Register a platform adapter
-     */
-    register(adapter: PlatformAdapter): void;
-    /**
-     * Get a specific platform adapter by name
-     */
-    get(name: string): PlatformAdapter | null;
-    /**
-     * Auto-detect and return the active platform
-     * Returns the first available platform in the registry
-     */
-    detect(): PlatformAdapter | null;
-    /**
-     * Get all registered platforms
-     */
-    getAll(): PlatformAdapter[];
+declare global {
+    interface Window {
+        openai: OpenAiAPI & OpenAiGlobals;
+    }
+    interface WindowEventMap {
+        [SET_GLOBALS_EVENT_TYPE]: SetGlobalsEvent;
+    }
 }
-/**
- * Create a new platform registry
- */
-declare function createPlatformRegistry(): PlatformRegistry;
 
-/**
- * Hook to access platform global state in a platform-agnostic way.
- * Works with any genAI platform (ChatGPT, Gemini, Claude, etc.)
- *
- * Uses React's useSyncExternalStore to efficiently subscribe to changes.
- *
- * @param key - The key of the global state to access
- * @returns The value of the global state, or null if not available
- *
- * @example
- * ```tsx
- * function MyWidget() {
- *   const colorScheme = usePlatformGlobal('colorScheme');
- *   const displayMode = usePlatformGlobal('displayMode');
- *
- *   return <div className={colorScheme === 'dark' ? 'dark' : 'light'}>...</div>;
- * }
- * ```
- */
-declare function usePlatformGlobal<K extends keyof PlatformGlobals>(key: K): PlatformGlobals[K] | null;
+type ScreenWidth = 'mobile-s' | 'mobile-l' | 'tablet' | 'full';
+type SimulatorConfig = {
+    theme: Theme;
+    displayMode: DisplayMode;
+    screenWidth: ScreenWidth;
+};
+declare const SCREEN_WIDTHS: Record<ScreenWidth, number>;
 
-/**
- * Hook to get the current display mode from the active genAI platform.
- * Display modes include: 'inline', 'fullscreen', and 'pip' (picture-in-picture).
- *
- * Works with any supported genAI platform (ChatGPT, Gemini, Claude, etc.)
- *
- * @returns The current display mode, or null if not in a supported environment
- */
-declare const useDisplayMode: () => DisplayMode$1 | null;
+declare const useDisplayMode: () => DisplayMode | null;
 
-/**
- * Hook to get the maximum height constraint from the active genAI platform.
- * Useful for ensuring your widget doesn't exceed the available space.
- *
- * Works with any supported genAI platform (ChatGPT, Gemini, Claude, etc.)
- *
- * @returns The maximum height in pixels, or null if not available
- */
 declare const useMaxHeight: () => number | null;
 
-/**
- * Hook to request a specific display mode from the platform
- *
- * @example
- * ```tsx
- * const requestDisplayMode = useRequestDisplayMode();
- *
- * const handleClick = async () => {
- *   await requestDisplayMode({ mode: 'fullscreen' });
- * };
- * ```
- */
-declare function useRequestDisplayMode(): RequestDisplayMode$1;
+declare function useIsMobile(): boolean;
 
-/**
- * Hook to get the current color scheme from the active genAI platform.
- * Color scheme can be 'light' or 'dark'.
- *
- * Works with any supported genAI platform (ChatGPT, Gemini, Claude, etc.)
- *
- * @returns The current color scheme, or null if not in a supported environment
- */
-declare const useColorScheme: () => Theme$1 | null;
+declare function useOpenAiGlobal<K extends keyof OpenAiGlobals>(key: K): OpenAiGlobals[K] | null;
 
-/**
- * Hook to get widget props (tool output) from the active genAI platform.
- * This contains the data returned by your server's tool.
- *
- * Works with any supported genAI platform (ChatGPT, Gemini, Claude, etc.)
- *
- * @param defaultState - Default state to use if no props are available
- * @returns The widget props from the tool output
- */
-declare function useWidgetProps<T extends Record<string, unknown>>(defaultState?: T | (() => T)): T;
+declare const useTheme: () => Theme | null;
 
-/**
- * Hook to manage widget state that persists in the active genAI platform.
- * Similar to useState, but syncs with the platform host page.
- *
- * Works with any supported genAI platform (ChatGPT, Gemini, Claude, etc.)
- *
- * @param defaultState - Default state value or function to generate it
- * @returns A tuple of [state, setState] similar to useState
- */
-declare function useWidgetState<T extends UnknownObject$1>(defaultState: T | (() => T)): readonly [T, (state: SetStateAction<T>) => void];
-declare function useWidgetState<T extends UnknownObject$1>(defaultState?: T | (() => T | null) | null): readonly [T | null, (state: SetStateAction<T | null>) => void];
+declare function useWidgetState<T extends UnknownObject = UnknownObject>(): [
+    T | null,
+    (state: T) => Promise<void>
+];
 
-/**
- * ChatGPT Theme
- *
- * Material UI theme implementing OpenAI ChatGPT Apps SDK design guidelines.
- *
- * @see https://developers.openai.com/apps-sdk/concepts/design-guidelines
- */
-/**
- * Create ChatGPT Light Theme
- */
-declare const chatgptLightTheme: _mui_material.Theme;
-/**
- * Create ChatGPT Dark Theme
- */
-declare const chatgptDarkTheme: _mui_material.Theme;
-/**
- * Get ChatGPT theme based on mode
- */
-declare const getChatGPTTheme: (mode: "light" | "dark") => _mui_material.Theme;
-
-/**
- * Base theme options that all platform themes extend
- */
-declare const baseThemeOptions: ThemeOptions;
-/**
- * Creates a base theme with common configuration
- */
-declare const createBaseTheme: () => _mui_material.Theme;
-
-/**
- * Theme System - Multi-Platform Support
- *
- * This module provides build-time theme substitution for multi-platform support.
- * The active theme is determined by the SUNPEAK_PLATFORM environment variable.
- *
- * Supported platforms:
- * - chatgpt (default): OpenAI ChatGPT Apps SDK
- * - Add more platforms as needed
- *
- * Usage:
- * ```bash
- * # Build for ChatGPT platform (default)
- * SUNPEAK_PLATFORM=chatgpt npm run build
- *
- * # Build for another platform (future)
- * SUNPEAK_PLATFORM=gemini npm run build
- * ```
- */
+interface ChatGPTSimulatorProps {
+    children: React.ReactNode;
+    appName?: string;
+    appIcon?: string;
+    userMessage?: string;
+}
+declare function ChatGPTSimulator({ children, appName, appIcon, userMessage }: ChatGPTSimulatorProps): react_jsx_runtime.JSX.Element;
+
+declare class MockOpenAI implements OpenAiAPI, OpenAiGlobals {
+    theme: Theme;
+    userAgent: {
+        device: {
+            type: "desktop";
+        };
+        capabilities: {
+            hover: boolean;
+            touch: boolean;
+        };
+    };
+    locale: string;
+    maxHeight: number;
+    displayMode: DisplayMode;
+    safeArea: {
+        insets: {
+            top: number;
+            bottom: number;
+            left: number;
+            right: number;
+        };
+    };
+    toolInput: {};
+    toolOutput: null;
+    toolResponseMetadata: null;
+    widgetState: Record<string, unknown> | null;
+    callTool(name: string, args: Record<string, unknown>): Promise<{
+        result: string;
+    }>;
+    sendFollowUpMessage(args: {
+        prompt: string;
+    }): Promise<void>;
+    openExternal(payload: {
+        href: string;
+    }): void;
+    requestDisplayMode(args: {
+        mode: DisplayMode;
+    }): Promise<{
+        mode: DisplayMode;
+    }>;
+    setWidgetState(state: Record<string, unknown>): Promise<void>;
+    setTheme(theme: Theme): void;
+    setDisplayMode(displayMode: DisplayMode): void;
+    private emitUpdate;
+}
+declare function initMockOpenAI(): MockOpenAI;
 
-/**
- * Platform identifier type
- */
-type Platform = 'chatgpt';
-/**
- * Get the current platform
- * Currently only supports 'chatgpt'
- * Future: Can be extended to support multiple platforms via build-time configuration
- */
-declare const getCurrentPlatform: () => Platform;
-/**
- * Theme getter function type
- */
-type ThemeGetter = (mode: 'light' | 'dark') => Theme$2;
-/**
- * Get theme for current platform
- * This is the main function used by components
- *
- * @param mode - Light or dark mode
- * @returns MUI Theme object for the current platform
- */
-declare const getTheme: (mode: "light" | "dark") => Theme$2;
-/**
- * Get light theme for current platform
- */
-declare const getLightTheme: () => Theme$2;
-/**
- * Get dark theme for current platform
- */
-declare const getDarkTheme: () => Theme$2;
+declare function cn(...inputs: ClassValue[]): string;
 
-export { type ButtonProps, type CallTool$1 as CallTool, type CallToolResponse$1 as CallToolResponse, Card, type CardProps, Carousel, type CarouselProps, type ChatGPTGlobals, ChatGPTSimulator, type ChatGPTSimulatorProps, type DeviceType$1 as DeviceType, type DisplayMode$1 as DisplayMode, GenAI, type GenAIProps, type GenAIRenderProps, type Platform, type PlatformAPI, type PlatformAdapter, type PlatformGlobals, PlatformProvider, type PlatformProviderProps, type PlatformRegistry, type PlatformType, type RequestDisplayMode$1 as RequestDisplayMode, type SafeArea$1 as SafeArea, type SafeAreaInsets$1 as SafeAreaInsets, type Theme$1 as Theme, type ThemeGetter, type UnknownObject$1 as UnknownObject, type UserAgent$1 as UserAgent, baseThemeOptions, chatgptDarkTheme, chatgptLightTheme, chatgptPlatform, createBaseTheme, createPlatformRegistry, getChatGPTTheme, getCurrentPlatform, getDarkTheme, getLightTheme, getTheme, useColorScheme, useDisplayMode, useMaxHeight, usePlatform, usePlatformGlobal, useRequestDisplayMode, useWidgetProps, useWidgetState };
+export { type CallTool, type CallToolResponse, ChatGPTSimulator, type DeviceType, type DisplayMode, type OpenAiAPI, type OpenAiGlobals, type RequestDisplayMode, SCREEN_WIDTHS, SET_GLOBALS_EVENT_TYPE, type SafeArea, type SafeAreaInsets, type ScreenWidth, SetGlobalsEvent, type SimulatorConfig, type Theme, ThemeProvider, type UnknownObject, type UserAgent, cn, initMockOpenAI, useDisplayMode, useIsMobile, useMaxHeight, useOpenAiGlobal, useTheme, useThemeContext, useWidgetState };