@aomi-labs/widget-lib 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,816 @@
+import { EventEmitter } from 'eventemitter3';
+
+declare const DEFAULT_WIDGET_WIDTH = "400px";
+declare const DEFAULT_WIDGET_HEIGHT = "600px";
+declare const DEFAULT_MAX_HEIGHT = 800;
+declare const DEFAULT_MESSAGE_LENGTH = 2000;
+declare const DEFAULT_RECONNECT_ATTEMPTS = 5;
+declare const DEFAULT_RECONNECT_DELAY = 3000;
+declare const SUPPORTED_CHAINS: Record<SupportedChainId, string>;
+declare const DEFAULT_CHAIN_ID: SupportedChainId;
+declare const THEME_PALETTES: Record<string, AomiChatWidgetPaletteColors>;
+declare const PREDEFINED_THEMES: Record<string, ThemeDefinition>;
+declare const ERROR_CODES: {
+    readonly INVALID_CONFIG: "INVALID_CONFIG";
+    readonly MISSING_APP_CODE: "MISSING_APP_CODE";
+    readonly INVALID_THEME: "INVALID_THEME";
+    readonly INVALID_DIMENSIONS: "INVALID_DIMENSIONS";
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+    readonly BACKEND_UNAVAILABLE: "BACKEND_UNAVAILABLE";
+    readonly AUTHENTICATION_FAILED: "AUTHENTICATION_FAILED";
+    readonly WALLET_NOT_CONNECTED: "WALLET_NOT_CONNECTED";
+    readonly WALLET_CONNECTION_FAILED: "WALLET_CONNECTION_FAILED";
+    readonly UNSUPPORTED_NETWORK: "UNSUPPORTED_NETWORK";
+    readonly TRANSACTION_FAILED: "TRANSACTION_FAILED";
+    readonly TRANSACTION_REJECTED: "TRANSACTION_REJECTED";
+    readonly MESSAGE_TOO_LONG: "MESSAGE_TOO_LONG";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly INVALID_MESSAGE: "INVALID_MESSAGE";
+    readonly SESSION_EXPIRED: "SESSION_EXPIRED";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+    readonly INITIALIZATION_FAILED: "INITIALIZATION_FAILED";
+    readonly PROVIDER_ERROR: "PROVIDER_ERROR";
+};
+declare const WIDGET_EVENTS: {
+    readonly READY: "ready";
+    readonly DESTROY: "destroy";
+    readonly RESIZE: "resize";
+    readonly MESSAGE: "message";
+    readonly TYPING_CHANGE: "typingChange";
+    readonly PROCESSING_CHANGE: "processingChange";
+    readonly CONNECTION_CHANGE: "connectionChange";
+    readonly SESSION_START: "sessionStart";
+    readonly SESSION_END: "sessionEnd";
+    readonly WALLET_CONNECT: "walletConnect";
+    readonly WALLET_DISCONNECT: "walletDisconnect";
+    readonly NETWORK_CHANGE: "networkChange";
+    readonly TRANSACTION_REQUEST: "transactionRequest";
+    readonly ERROR: "error";
+};
+declare const CSS_CLASSES: {
+    readonly WIDGET_ROOT: "aomi-chat-widget";
+    readonly WIDGET_CONTAINER: "aomi-chat-container";
+    readonly WIDGET_IFRAME: "aomi-chat-iframe";
+    readonly THEME_LIGHT: "aomi-theme-light";
+    readonly THEME_DARK: "aomi-theme-dark";
+    readonly THEME_TERMINAL: "aomi-theme-terminal";
+    readonly THEME_NEON: "aomi-theme-neon";
+    readonly THEME_MINIMAL: "aomi-theme-minimal";
+    readonly MODE_FULL: "aomi-mode-full";
+    readonly MODE_MINIMAL: "aomi-mode-minimal";
+    readonly MODE_COMPACT: "aomi-mode-compact";
+    readonly MODE_TERMINAL: "aomi-mode-terminal";
+    readonly CHAT_INTERFACE: "aomi-chat-interface";
+    readonly CHAT_HEADER: "aomi-chat-header";
+    readonly CHAT_TITLE: "aomi-chat-title";
+    readonly CHAT_BODY: "aomi-chat-body";
+    readonly STATUS_BADGE: "aomi-status-badge";
+    readonly MESSAGE_LIST: "aomi-message-list";
+    readonly MESSAGE_CONTAINER: "aomi-message-container";
+    readonly MESSAGE_BUBBLE: "aomi-message";
+    readonly MESSAGE_USER: "aomi-message-user";
+    readonly MESSAGE_ASSISTANT: "aomi-message-assistant";
+    readonly MESSAGE_SYSTEM: "aomi-message-system";
+    readonly ACTION_BAR: "aomi-action-bar";
+    readonly MESSAGE_INPUT: "aomi-message-input";
+    readonly INPUT_FORM: "aomi-chat-input-form";
+    readonly INPUT_FIELD: "aomi-chat-input-field";
+    readonly SEND_BUTTON: "aomi-chat-send-button";
+    readonly WALLET_STATUS: "aomi-wallet-status";
+    readonly TYPING_INDICATOR: "aomi-typing-indicator";
+    readonly LOADING: "aomi-loading";
+    readonly ERROR: "aomi-error";
+    readonly DISABLED: "aomi-disabled";
+    readonly CONNECTED: "aomi-connected";
+    readonly DISCONNECTED: "aomi-disconnected";
+};
+declare const API_ENDPOINTS: {
+    readonly CHAT: "/api/chat";
+    readonly CHAT_STREAM: "/api/chat/stream";
+    readonly STATE: "/api/state";
+    readonly INTERRUPT: "/api/interrupt";
+    readonly SYSTEM: "/api/system";
+    readonly MCP_COMMAND: "/api/mcp-command";
+    readonly HEALTH: "/health";
+};
+declare const TIMING: {
+    readonly TYPING_INDICATOR_DELAY: 100;
+    readonly MESSAGE_ANIMATION_DURATION: 300;
+    readonly CONNECTION_TIMEOUT: 10000;
+    readonly RETRY_DELAY: 1000;
+    readonly HEARTBEAT_INTERVAL: 30000;
+    readonly SESSION_TIMEOUT: 3600000;
+};
+
+declare class AomiChatError$1 extends Error {
+    readonly code: string;
+    readonly timestamp: Date;
+    readonly details?: unknown;
+    constructor(code: string, message: string, details?: unknown);
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+        timestamp: string;
+        details: unknown;
+        stack: string | undefined;
+    };
+    toString(): string;
+}
+declare class ConfigurationError extends AomiChatError$1 {
+    constructor(message: string, details?: unknown);
+}
+declare class ConnectionError extends AomiChatError$1 {
+    constructor(message: string, details?: unknown);
+}
+declare class WalletError extends AomiChatError$1 {
+    constructor(code: string, message: string, details?: unknown);
+}
+declare class TransactionError extends WalletError {
+    constructor(message: string, details?: unknown);
+}
+declare class ChatError extends AomiChatError$1 {
+    constructor(code: string, message: string, details?: unknown);
+}
+declare class RateLimitError extends ChatError {
+    constructor(message: string, details?: unknown);
+}
+declare class SessionError extends AomiChatError$1 {
+    constructor(message: string, details?: unknown);
+}
+declare function createConfigurationError(message: string, details?: unknown): ConfigurationError;
+declare function createConnectionError(message: string, details?: unknown): ConnectionError;
+declare function createWalletError(code: string, message: string, details?: unknown): WalletError;
+declare function createTransactionError(message: string, details?: unknown): TransactionError;
+declare function createChatError(code: string, message: string, details?: unknown): ChatError;
+declare function createRateLimitError(message: string, details?: unknown): RateLimitError;
+declare function createSessionError(message: string, details?: unknown): SessionError;
+declare function isAomiChatError(error: unknown): error is AomiChatError$1;
+declare function isConfigurationError(error: unknown): error is ConfigurationError;
+declare function isConnectionError(error: unknown): error is ConnectionError;
+declare function isWalletError(error: unknown): error is WalletError;
+declare function isTransactionError(error: unknown): error is TransactionError;
+declare function isChatError(error: unknown): error is ChatError;
+declare function isRateLimitError(error: unknown): error is RateLimitError;
+declare function isSessionError(error: unknown): error is SessionError;
+
+type SupportedChainId = 1 | 5 | 10 | 100 | 1337 | 31337 | 137 | 42161 | 59140 | 59144 | 8453 | 11155111;
+type PerNetworkConfig<T> = Partial<Record<SupportedChainId, T>>;
+type PerModeConfig<T> = Partial<Record<AomiChatMode, T>>;
+type FlexibleConfig<T> = T | PerNetworkConfig<T> | PerModeConfig<T> | PerModeConfig<PerNetworkConfig<T>> | PerNetworkConfig<PerModeConfig<T>>;
+interface ChatMessage {
+    id: string;
+    type: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: Date;
+    toolStream?: {
+        topic: string;
+        content: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface WalletTransaction {
+    to: string;
+    value: string;
+    data: string;
+    gas?: string;
+    description: string;
+    timestamp: string;
+}
+type AomiChatMode = 'full' | 'minimal' | 'compact' | 'terminal';
+type AomiChatTheme = 'light' | 'dark' | 'terminal' | 'neon' | 'minimal';
+interface AomiChatWidgetPaletteColors {
+    primary: string;
+    background: string;
+    surface: string;
+    text: string;
+    textSecondary: string;
+    border: string;
+    success: string;
+    error: string;
+    warning: string;
+    accent: string;
+}
+interface AomiChatWidgetPalette extends AomiChatWidgetPaletteColors {
+    baseTheme: AomiChatTheme;
+}
+interface RateLimitConfig {
+    maxMessages?: number;
+    windowMs?: number;
+    skipWhenConnected?: boolean;
+}
+interface AnalyticsConfig {
+    trackEvents?: boolean;
+    customId?: string;
+    excludeContent?: boolean;
+}
+interface ChatCommand {
+    command: string;
+    description: string;
+    handler: (args: string[]) => Promise<void> | void;
+}
+interface AomiChatWidgetParams {
+    appCode: string;
+    width?: string;
+    height?: string;
+    maxHeight?: number;
+    baseUrl?: string;
+    sessionId?: string;
+    theme?: AomiChatTheme | AomiChatWidgetPalette;
+    mode?: AomiChatMode;
+    welcomeMessage?: string;
+    placeholder?: string;
+    showWalletStatus?: boolean;
+    showNetworkSelector?: boolean;
+    hideHeader?: boolean;
+    hideFooter?: boolean;
+    chainId?: SupportedChainId;
+    supportedChains?: SupportedChainId[];
+    enableTransactions?: boolean;
+    requireWalletConnection?: boolean;
+    sessionPersistence?: boolean;
+    autoConnect?: boolean;
+    standaloneMode?: boolean;
+    customCommands?: ChatCommand[];
+    rateLimiting?: FlexibleConfig<RateLimitConfig>;
+    apiKey?: string;
+    webhookUrl?: string;
+    analytics?: AnalyticsConfig;
+    sounds?: {
+        messageReceived?: string | null;
+        messageSent?: string | null;
+        transactionSuccess?: string | null;
+        transactionError?: string | null;
+    };
+    content?: {
+        welcomeTitle?: string;
+        connectWalletText?: string;
+        disconnectText?: string;
+        networkSwitchText?: string;
+        errorMessages?: Record<string, string>;
+    };
+}
+declare enum ConnectionStatus {
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected",
+    ERROR = "error",
+    RECONNECTING = "reconnecting"
+}
+declare enum ReadinessPhase {
+    INITIALIZING = "initializing",
+    CONNECTING_MCP = "connecting_mcp",
+    VALIDATING_ANTHROPIC = "validating_anthropic",
+    READY = "ready",
+    MISSING_API_KEY = "missing_api_key",
+    ERROR = "error"
+}
+interface BackendReadiness {
+    phase: ReadinessPhase;
+    detail?: string;
+    retryCount?: number;
+}
+interface WalletState {
+    isConnected: boolean;
+    address?: string;
+    chainId?: SupportedChainId;
+    networkName?: string;
+    balance?: string;
+}
+interface ChatState {
+    messages: ChatMessage[];
+    isTyping: boolean;
+    isProcessing: boolean;
+    connectionStatus: ConnectionStatus;
+    readiness: BackendReadiness;
+    walletState: WalletState;
+    sessionId: string;
+    pendingTransaction?: WalletTransaction;
+}
+interface AomiChatEventListeners {
+    onReady?: () => void;
+    onMessage?: (message: ChatMessage) => void;
+    onTransactionRequest?: (transaction: WalletTransaction) => void;
+    onError?: (error: AomiChatError) => void;
+    onSessionStart?: (sessionId: string) => void;
+    onSessionEnd?: (sessionId: string) => void;
+    onNetworkChange?: (chainId: SupportedChainId) => void;
+    onWalletConnect?: (address: string) => void;
+    onWalletDisconnect?: () => void;
+    onTypingChange?: (isTyping: boolean) => void;
+    onProcessingChange?: (isProcessing: boolean) => void;
+    onConnectionChange?: (status: ConnectionStatus) => void;
+    onResize?: (dimensions: {
+        width: number;
+        height: number;
+    }) => void;
+}
+interface AomiChatError {
+    code: string;
+    message: string;
+    details?: unknown;
+    timestamp: Date;
+}
+interface AomiChatWidgetHandler {
+    sendMessage: (message: string) => Promise<void>;
+    updateParams: (params: Partial<AomiChatWidgetParams>) => void;
+    updateProvider: (provider?: EthereumProvider) => void;
+    destroy: () => void;
+    getState: () => ChatState;
+    getSessionId: () => string;
+    isReady: () => boolean;
+    on: <K extends keyof AomiChatEventListeners>(event: K, listener: NonNullable<AomiChatEventListeners[K]>) => AomiChatWidgetHandler;
+    off: <K extends keyof AomiChatEventListeners>(event: K, listener: NonNullable<AomiChatEventListeners[K]>) => AomiChatWidgetHandler;
+    clearChat: () => void;
+    exportChat: () => ChatMessage[];
+    resize: (width?: string, height?: string) => void;
+    focus: () => void;
+}
+interface JsonRpcRequest {
+    id: number;
+    method: string;
+    params: unknown[];
+}
+interface EthereumProvider {
+    request<T>(params: JsonRpcRequest): Promise<T>;
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    removeListener?(event: string, handler: (...args: unknown[]) => void): void;
+    isMetaMask?: boolean;
+    isWalletConnect?: boolean;
+}
+interface WidgetConfig {
+    params: AomiChatWidgetParams;
+    provider?: EthereumProvider;
+    listeners?: AomiChatEventListeners;
+}
+interface ChatManagerConfig {
+    backendUrl: string;
+    sessionId: string;
+    maxMessageLength?: number;
+    reconnectAttempts?: number;
+    reconnectDelay?: number;
+}
+interface ChatInterfaceProps {
+    messages: ChatMessage[];
+    isTyping: boolean;
+    isProcessing: boolean;
+    onSendMessage: (message: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+interface MessageListProps {
+    messages: ChatMessage[];
+    isTyping: boolean;
+    className?: string;
+}
+interface MessageInputProps {
+    onSendMessage: (message: string) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    maxLength?: number;
+    className?: string;
+}
+interface WalletStatusProps {
+    walletState: WalletState;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onNetworkSwitch?: (chainId: SupportedChainId) => void;
+    showNetworkSelector?: boolean;
+    className?: string;
+}
+interface TypingIndicatorProps {
+    isTyping: boolean;
+    className?: string;
+}
+interface ThemeDefinition {
+    name: string;
+    palette: AomiChatWidgetPaletteColors;
+    fonts?: {
+        primary?: string;
+        monospace?: string;
+    };
+    spacing?: {
+        xs?: string;
+        sm?: string;
+        md?: string;
+        lg?: string;
+        xl?: string;
+    };
+    borderRadius?: {
+        sm?: string;
+        md?: string;
+        lg?: string;
+    };
+    shadows?: {
+        sm?: string;
+        md?: string;
+        lg?: string;
+    };
+}
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+type RequiredKeys<T, K extends keyof T> = T & Required<Pick<T, K>>;
+type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/**
+ * Creates and initializes an Aomi Chat Widget
+ */
+declare function createAomiChatWidget(container: HTMLElement, config: WidgetConfig): AomiChatWidgetHandler;
+
+interface ChatManagerEvents {
+    stateChange: [ChatState];
+    message: [ChatMessage];
+    error: [AomiChatError];
+    connectionChange: [ConnectionStatus];
+    transactionRequest: [WalletTransaction];
+}
+type NetworkSwitchResult = {
+    success: boolean;
+    message: string;
+    data?: Record<string, unknown>;
+};
+declare class ChatManager extends EventEmitter<ChatManagerEvents> {
+    private config;
+    private state;
+    private eventSource;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private lastPendingTransactionRaw;
+    constructor(config?: Partial<ChatManagerConfig>);
+    getState(): ChatState;
+    getSessionId(): string;
+    setSessionId(sessionId: string): void;
+    connectSSE(): Promise<void>;
+    disconnectSSE(): void;
+    sendMessage(message: string): Promise<void>;
+    sendSystemMessage(message: string): Promise<void>;
+    interrupt(): Promise<void>;
+    sendNetworkSwitchRequest(networkName: string): Promise<NetworkSwitchResult>;
+    sendTransactionResult(success: boolean, transactionHash?: string, error?: string): Promise<void>;
+    clearPendingTransaction(): void;
+    clearMessages(): void;
+    updateWalletState(walletState: Partial<WalletState>): void;
+    destroy(): void;
+    private processBackendPayload;
+    private buildMessages;
+    private normaliseSender;
+    private parseTimestamp;
+    private normaliseReadiness;
+    private updateReadiness;
+    private setConnectionStatus;
+    private emitStateChange;
+    private postToBackend;
+    private refreshState;
+    private handleConnectionError;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private teardownEventSource;
+}
+
+declare class ThemeManager {
+    private currentTheme;
+    private customPalette;
+    constructor(theme?: AomiChatTheme | AomiChatWidgetPalette);
+    /**
+     * Updates the current theme
+     */
+    updateTheme(theme?: AomiChatTheme | AomiChatWidgetPalette): void;
+    /**
+     * Gets the current computed theme
+     */
+    getComputedTheme(): ThemeDefinition;
+    /**
+     * Gets a specific color from the current theme
+     */
+    getColor(colorKey: keyof AomiChatWidgetPaletteColors): string;
+    /**
+     * Gets the CSS class name for the current theme
+     */
+    getThemeClass(): string;
+    /**
+     * Gets the font family for the current theme
+     */
+    getFontFamily(): string;
+    /**
+     * Gets the monospace font family for the current theme
+     */
+    getMonospaceFontFamily(): string;
+    /**
+     * Gets a spacing value for the current theme
+     */
+    getSpacing(size: 'xs' | 'sm' | 'md' | 'lg' | 'xl'): string;
+    /**
+     * Gets a border radius value for the current theme
+     */
+    getBorderRadius(size: 'sm' | 'md' | 'lg'): string;
+    /**
+     * Gets a shadow value for the current theme
+     */
+    getShadow(size: 'sm' | 'md' | 'lg'): string;
+    /**
+     * Generates CSS custom properties for the current theme
+     */
+    getCSSCustomProperties(): Record<string, string>;
+    /**
+     * Applies the theme to a DOM element
+     */
+    applyThemeToElement(element: HTMLElement): void;
+    /**
+     * Generates CSS string for the current theme
+     */
+    generateCSS(selector?: string): string;
+    /**
+     * Destroys the theme manager
+     */
+    destroy(): void;
+    private resolveTheme;
+    private isCustomPalette;
+    private getBaseThemeName;
+    private isPaletteEqual;
+    private generateComponentCSS;
+}
+/**
+ * Creates a theme manager instance
+ */
+declare function createThemeManager(theme?: AomiChatTheme | AomiChatWidgetPalette): ThemeManager;
+/**
+ * Gets all available predefined themes
+ */
+declare function getAvailableThemes(): Record<string, ThemeDefinition>;
+/**
+ * Validates a custom palette
+ */
+declare function validateCustomPalette(palette: unknown): palette is AomiChatWidgetPalette;
+/**
+ * Creates a custom palette from a base theme
+ */
+declare function createCustomPalette(baseTheme: AomiChatTheme, overrides: Partial<AomiChatWidgetPaletteColors>): AomiChatWidgetPalette;
+
+interface TransactionRequest {
+    to: string;
+    value: string;
+    data: string;
+    gas?: string;
+}
+interface WalletManagerEvents {
+    connect: [string];
+    disconnect: [];
+    chainChange: [SupportedChainId];
+    accountsChange: [string[]];
+    error: [AomiChatError];
+}
+declare class WalletManager extends EventEmitter<WalletManagerEvents> {
+    private provider;
+    private currentAccount;
+    private currentChainId;
+    private isConnected;
+    constructor(provider: EthereumProvider);
+    /**
+     * Gets the current connected account
+     */
+    getCurrentAccount(): string | null;
+    /**
+     * Gets the current chain ID
+     */
+    getCurrentChainId(): SupportedChainId | null;
+    /**
+     * Gets the current network name
+     */
+    getCurrentNetworkName(): string | null;
+    /**
+     * Checks if wallet is connected
+     */
+    getIsConnected(): boolean;
+    /**
+     * Connects to the wallet
+     */
+    connect(): Promise<string>;
+    /**
+     * Disconnects from the wallet
+     */
+    disconnect(): void;
+    /**
+     * Switches to a specific network
+     */
+    switchNetwork(chainId: SupportedChainId): Promise<void>;
+    /**
+     * Sends a transaction
+     */
+    sendTransaction(transaction: TransactionRequest): Promise<string>;
+    /**
+     * Signs a message
+     */
+    signMessage(message: string): Promise<string>;
+    /**
+     * Gets account balance
+     */
+    getBalance(address?: string): Promise<string>;
+    /**
+     * Updates the provider
+     */
+    updateProvider(provider: EthereumProvider): void;
+    /**
+     * Destroys the wallet manager
+     */
+    destroy(): void;
+    private initializeState;
+    private updateChainId;
+    private setupEventListeners;
+    private removeProviderListeners;
+    private handleAccountsChanged;
+    private handleChainChanged;
+    private handleDisconnect;
+    private validateTransaction;
+    private addNetwork;
+    private getNetworkConfig;
+}
+/**
+ * Creates a wallet manager instance
+ */
+declare function createWalletManager(provider: EthereumProvider): WalletManager;
+/**
+ * Checks if a provider supports the required methods
+ */
+declare function isValidProvider(provider: unknown): provider is EthereumProvider;
+/**
+ * Detects available wallets
+ */
+declare function detectWallets(): Array<{
+    name: string;
+    provider: EthereumProvider;
+}>;
+declare global {
+    interface Window {
+        ethereum?: EthereumProvider & {
+            isMetaMask?: boolean;
+            isWalletConnect?: boolean;
+        };
+    }
+}
+
+/**
+ * Resolves a flexible configuration value based on chain ID and mode
+ */
+declare function resolveFlexibleConfig<T>(config: FlexibleConfig<T>, chainId: SupportedChainId, mode: AomiChatMode): T | undefined;
+/**
+ * Validates widget configuration parameters
+ */
+declare function validateWidgetParams(params: AomiChatWidgetParams): string[];
+/**
+ * Generates a unique session ID
+ */
+declare function generateSessionId(): string;
+/**
+ * Validates a session ID format
+ */
+declare function isValidSessionId(sessionId: string): boolean;
+/**
+ * Builds widget URL with parameters
+ */
+declare function buildWidgetUrl(baseUrl: string, params: AomiChatWidgetParams): string;
+/**
+ * Parses widget parameters from URL search params
+ */
+declare function parseWidgetParams(searchParams: URLSearchParams): Partial<AomiChatWidgetParams>;
+/**
+ * Creates a DOM element with classes and attributes
+ */
+declare function createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: {
+    className?: string | string[];
+    attributes?: Record<string, string>;
+    styles?: Partial<CSSStyleDeclaration>;
+    children?: (HTMLElement | string)[];
+}): HTMLElementTagNameMap[K];
+/**
+ * Checks if an element is visible in the viewport
+ */
+declare function isElementVisible(element: HTMLElement): boolean;
+/**
+ * Type guard to check if a value is a valid Ethereum address
+ */
+declare function isEthereumAddress(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a valid transaction hash
+ */
+declare function isTransactionHash(value: unknown): value is string;
+/**
+ * Type guard to check if an object has a specific property
+ */
+declare function hasProperty<T extends object, K extends string | number | symbol>(obj: T, prop: K): obj is T & Record<K, unknown>;
+/**
+ * Delays execution for a specified number of milliseconds
+ */
+declare function delay(ms: number): Promise<void>;
+/**
+ * Creates a promise that rejects after a timeout
+ */
+declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T>;
+/**
+ * Retries a function with exponential backoff
+ */
+declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    delay?: number;
+    backoffFactor?: number;
+    shouldRetry?: (error: unknown) => boolean;
+}): Promise<T>;
+/**
+ * Detects if running in a browser environment
+ */
+declare function isBrowser(): boolean;
+/**
+ * Detects if running on a mobile device
+ */
+declare function isMobile(): boolean;
+/**
+ * Gets the current viewport dimensions
+ */
+declare function getViewportDimensions(): {
+    width: number;
+    height: number;
+};
+/**
+ * Formats a timestamp as a human-readable string
+ */
+declare function formatTimestamp(timestamp: Date): string;
+/**
+ * Truncates an Ethereum address for display
+ */
+declare function truncateAddress(address: string, startChars?: number, endChars?: number): string;
+/**
+ * Formats a number with appropriate decimal places
+ */
+declare function formatNumber(value: number, options?: {
+    decimals?: number;
+    compact?: boolean;
+    currency?: string;
+}): string;
+
+declare const VERSION = "0.1.0";
+
+interface CreateChatWidgetOptions {
+    appCode: string;
+    theme?: AomiChatTheme | AomiChatWidgetPalette;
+    width?: string;
+    height?: string;
+    baseUrl?: string;
+    provider?: EthereumProvider;
+    onReady?: () => void;
+    onMessage?: (message: ChatMessage) => void;
+    onError?: (error: AomiChatError) => void;
+}
+declare function createChatWidget(containerId: string | HTMLElement, options: CreateChatWidgetOptions): AomiChatWidgetHandler;
+declare const _default: {
+    createChatWidget: typeof createChatWidget;
+    createAomiChatWidget: typeof createAomiChatWidget;
+    VERSION: string;
+    SUPPORTED_CHAINS: Record<SupportedChainId, string>;
+    PREDEFINED_THEMES: Record<string, ThemeDefinition>;
+    ERROR_CODES: {
+        readonly INVALID_CONFIG: "INVALID_CONFIG";
+        readonly MISSING_APP_CODE: "MISSING_APP_CODE";
+        readonly INVALID_THEME: "INVALID_THEME";
+        readonly INVALID_DIMENSIONS: "INVALID_DIMENSIONS";
+        readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+        readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+        readonly BACKEND_UNAVAILABLE: "BACKEND_UNAVAILABLE";
+        readonly AUTHENTICATION_FAILED: "AUTHENTICATION_FAILED";
+        readonly WALLET_NOT_CONNECTED: "WALLET_NOT_CONNECTED";
+        readonly WALLET_CONNECTION_FAILED: "WALLET_CONNECTION_FAILED";
+        readonly UNSUPPORTED_NETWORK: "UNSUPPORTED_NETWORK";
+        readonly TRANSACTION_FAILED: "TRANSACTION_FAILED";
+        readonly TRANSACTION_REJECTED: "TRANSACTION_REJECTED";
+        readonly MESSAGE_TOO_LONG: "MESSAGE_TOO_LONG";
+        readonly RATE_LIMITED: "RATE_LIMITED";
+        readonly INVALID_MESSAGE: "INVALID_MESSAGE";
+        readonly SESSION_EXPIRED: "SESSION_EXPIRED";
+        readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+        readonly INITIALIZATION_FAILED: "INITIALIZATION_FAILED";
+        readonly PROVIDER_ERROR: "PROVIDER_ERROR";
+    };
+    WIDGET_EVENTS: {
+        readonly READY: "ready";
+        readonly DESTROY: "destroy";
+        readonly RESIZE: "resize";
+        readonly MESSAGE: "message";
+        readonly TYPING_CHANGE: "typingChange";
+        readonly PROCESSING_CHANGE: "processingChange";
+        readonly CONNECTION_CHANGE: "connectionChange";
+        readonly SESSION_START: "sessionStart";
+        readonly SESSION_END: "sessionEnd";
+        readonly WALLET_CONNECT: "walletConnect";
+        readonly WALLET_DISCONNECT: "walletDisconnect";
+        readonly NETWORK_CHANGE: "networkChange";
+        readonly TRANSACTION_REQUEST: "transactionRequest";
+        readonly ERROR: "error";
+    };
+};
+
+export { API_ENDPOINTS, AomiChatError$1 as AomiChatError, CSS_CLASSES, ChatError, ChatManager, ConfigurationError, ConnectionError, ConnectionStatus, DEFAULT_CHAIN_ID, DEFAULT_MAX_HEIGHT, DEFAULT_MESSAGE_LENGTH, DEFAULT_RECONNECT_ATTEMPTS, DEFAULT_RECONNECT_DELAY, DEFAULT_WIDGET_HEIGHT, DEFAULT_WIDGET_WIDTH, ERROR_CODES, PREDEFINED_THEMES, RateLimitError, ReadinessPhase, SUPPORTED_CHAINS, SessionError, THEME_PALETTES, TIMING, ThemeManager, TransactionError, VERSION, WIDGET_EVENTS, WalletError, WalletManager, buildWidgetUrl, createAomiChatWidget, createChatError, createChatWidget, createConfigurationError, createConnectionError, createCustomPalette, createElement, createRateLimitError, createSessionError, createThemeManager, createTransactionError, createWalletError, createWalletManager, _default as default, delay, detectWallets, formatNumber, formatTimestamp, generateSessionId, getAvailableThemes, getViewportDimensions, hasProperty, isAomiChatError, isBrowser, isChatError, isConfigurationError, isConnectionError, isElementVisible, isEthereumAddress, isMobile, isRateLimitError, isSessionError, isTransactionError, isTransactionHash, isValidProvider, isValidSessionId, isWalletError, parseWidgetParams, resolveFlexibleConfig, retry, truncateAddress, validateCustomPalette, validateWidgetParams, withTimeout };
+export type { AomiChatEventListeners, AomiChatMode, AomiChatTheme, AomiChatWidgetHandler, AomiChatWidgetPalette, AomiChatWidgetPaletteColors, AomiChatWidgetParams, BackendReadiness, ChatInterfaceProps, ChatMessage, ChatState, DeepPartial, EthereumProvider, FlexibleConfig, JsonRpcRequest, MessageInputProps, MessageListProps, OptionalKeys, RequiredKeys, SupportedChainId, ThemeDefinition, TypingIndicatorProps, WalletState, WalletStatusProps, WalletTransaction, WidgetConfig };