export type DisplayMode = 'center' | 'bottom-right';
export type TriggerMode = 'user' | 'websocket';
export type Theme = 'light' | 'dark';
export type { TokenInfo } from '@/lib/tokenUtils';
/**
 * Simplified configuration for initializing the Aria SDK.
 *
 * This is the minimal configuration required to get started.
 * All session management, reconnection, and refresh logic is handled internally.
 *
 * @example
 * ```typescript
 * import { Aria } from '@centive/aria-sdk';
 *
 * Aria.init({
 *   websocketUrl: 'wss://your-server.com/ws',
 *   userId: 'user_123',
 *   theme: 'light',
 *   onError: (err) => console.error(err),
 * });
 * ```
 */
export interface AriaInitConfig {
    /**
     * WebSocket server URL for connecting to your backend.
     * Your backend handles session token generation and persona configuration.
     *
     * @example 'wss://api.example.com/ws' or 'ws://localhost:8000/ws'
     */
    websocketUrl: string;
    /**
     * Unique identifier for the current user.
     * Used by the backend for:
     * - Persona selection based on user context
     * - Message accumulation and history
     * - Session management
     */
    userId: string;
    /**
     * UI theme for the assistant widget.
     * @default 'light'
     */
    theme?: Theme;
    /**
     * Custom label for the floating trigger button.
     * If not provided, only the avatar icon is shown.
     *
     * @example 'Help', 'Chat with Aria', 'Support'
     */
    triggerLabel?: string;
    /**
     * Callback for handling errors from the SDK.
     * Use this for logging, error tracking, or user notifications.
     *
     * @example
     * ```typescript
     * onError: (error) => {
     *   console.error('Aria SDK error:', error);
     *   Sentry.captureException(error);
     * }
     * ```
     */
    onError?: (error: Error) => void;
}
export interface WebSocketTriggerEvent {
    type: 'trigger_event';
    data: {
        message?: string;
        caller?: string;
        eventType?: string;
        timestamp?: string;
        [key: string]: unknown;
    };
}
export interface AriaSDKConfig {
    websocketUrl: string;
    triggerLabel?: string;
    theme?: Theme;
    userId?: string;
    onError?: (error: Error) => void;
    onSessionReady?: () => void;
    onConnectionStateChange?: (connected: boolean) => void;
    onWebSocketEvent?: (event: WebSocketTriggerEvent) => void;
    onMessageHistoryAck?: (messageCount: number) => void;
    onMessageStreamAck?: () => void;
    onSessionEndAck?: (savedCount: number) => void;
    onSessionEndError?: (error: string, errorType: string) => void;
    onManualTrigger?: (userId: string) => void;
    /** @deprecated Use preloadSession instead. This option will be removed in a future version. */
    autoTriggerOnMount?: boolean;
    showFloatingButton?: boolean;
    showAssistant?: boolean;
    /** Enable session preloading on provider mount (default: true) */
    preloadSession?: boolean;
    /** Minutes before session expiry to trigger refresh (default: 5) */
    sessionRefreshBuffer?: number;
    /** Callback when session is preloaded and ready */
    onSessionPreloaded?: () => void;
    /** Callback when session refresh occurs */
    onSessionRefresh?: () => void;
    /** Callback when session refresh fails */
    onSessionRefreshError?: (error: Error) => void;
    /**
     * When true, keeps the session alive when widget is closed.
     * Session only ends on: tab close, logout, session expiry, or explicit stopSession() call.
     * Default: false (current behavior - session ends when widget closes)
     */
    persistSession?: boolean;
    /**
     * When persistSession is true, optionally keep WebSocket connected in background.
     * If false, reconnects using stored session token when widget reopens.
     * Default: true (keep WebSocket alive for faster reconnection)
     */
    keepWebSocketAlive?: boolean;
    /** Callback when session is paused (widget closed with persistSession: true) */
    onSessionPaused?: () => void;
    /** Callback when session is resumed (widget reopened with existing session) */
    onSessionResumed?: () => void;
}
export interface ChatMessage {
    role: 'user' | 'persona';
    content: string;
    timestamp: number;
}
export interface AnamMessageStreamEvent {
    role: 'user' | 'persona';
    content: string;
    is_final?: boolean;
}
export interface SessionData {
    session_id?: string;
    token?: string;
    sessionToken?: string;
    expires_at?: string;
}
export interface SessionSuccessResponse {
    status: 'success';
    message: string;
    session_data: SessionData | null;
    time_taken: number;
}
export type SessionErrorType = 'INVALID_JSON' | 'NO_USER' | 'AuthError' | 'ValidationError' | 'RateLimitError' | 'ServerError' | 'NetworkError' | 'CIRCUIT_BREAKER_OPEN';
export interface SessionErrorResponse {
    status: 'error';
    message: string;
    error: SessionErrorType | string;
    time_taken?: number;
}
export type SessionResponse = SessionSuccessResponse | SessionErrorResponse;
export interface UserTriggerMessage {
    user_trigger: boolean;
    userId?: string;
    /** Skip the initial greeting (used when resuming after hang up) */
    skip_greeting?: boolean;
}
export interface TriggerSessionOptions {
    userTrigger?: boolean;
}
export interface SessionState {
    session_id: string | null;
    token: string | null;
    expires_at: string | null;
    isSessionReady: boolean;
    lastError: string | null;
    /** Whether the session was preloaded (ready before widget opened) */
    isPreloaded: boolean;
    /** Whether a session refresh is in progress */
    isRefreshing: boolean;
}
/** Status of the session manager */
export type SessionManagerStatus = 'idle' | 'connecting' | 'connected' | 'preloading' | 'ready' | 'refreshing' | 'error';
/** Event types emitted by the session manager */
export type SessionManagerEventType = 'status_change' | 'session_ready' | 'session_refresh' | 'session_error' | 'connection_change' | 'message_history' | 'message_stream' | 'tool_call' | 'reconnecting';
/** Listener callback for session manager events */
export type SessionManagerListener = (event: SessionManagerEvent) => void;
/** Event object emitted by session manager */
export interface SessionManagerEvent {
    type: SessionManagerEventType;
    data?: unknown;
    error?: Error;
}
/** Configuration for session refresh behavior */
export interface SessionRefreshConfig {
    /** Minutes before expiry to trigger refresh (default: 5) */
    bufferMinutes: number;
    /** Maximum retry attempts for refresh (default: 3) */
    maxRetries: number;
    /** Base delay for exponential backoff in ms (default: 1000) */
    baseRetryDelay: number;
    /** Only refresh when tab is visible (default: true) */
    refreshOnlyWhenVisible: boolean;
}
export interface AnamMessage {
    role: 'user' | 'persona';
    content: string;
    timestamp: string;
}
export interface MessageHistoryEvent {
    type: 'message_history';
    session_id: string;
    user_id: string;
    messages: AnamMessage[];
}
export interface MessageStreamEvent {
    type: 'message_stream';
    session_id: string;
    user_id: string;
    message: {
        role: 'user' | 'persona';
        content: string;
        timestamp: string;
        is_final: boolean;
    };
}
export interface SessionEndEvent {
    type: 'session_end';
    session_id: string;
    user_id: string;
}
export interface MessageHistoryAckResponse {
    status: 'ok';
    type: 'message_history_ack';
    message_count: number;
}
export interface MessageStreamAckResponse {
    status: 'ok';
    type: 'message_stream_ack';
}
export interface SessionEndAckResponse {
    status: 'ok';
    type: 'session_end_ack';
    message: string;
    saved_count: number;
}
export interface SessionEndErrorResponse {
    status: 'error';
    type: 'session_end_error';
    message: string;
    error: SessionErrorType | string;
}
export interface GenericAckResponse {
    status: 'ok';
    message: string;
}
export interface MissingFieldsErrorResponse {
    status: 'error';
    message: string;
    error: 'MISSING_FIELDS';
}
/** Tool call event from Anam SDK */
export interface ClientToolEvent {
    eventUid: string;
    sessionId: string;
    eventName: string;
    eventData: Record<string, unknown>;
    timestamp: string;
    timestampUserAction: string;
    userActionCorrelationId: string;
}
/** Tool call state for UI display */
export interface ToolCallState {
    isActive: boolean;
    toolName: string | null;
    toolData: Record<string, unknown> | null;
}
export type FrontendToBackendMessage = UserTriggerMessage | MessageHistoryEvent | MessageStreamEvent | SessionEndEvent;
export type BackendToFrontendMessage = SessionResponse | MessageHistoryAckResponse | MessageStreamAckResponse | SessionEndAckResponse | SessionEndErrorResponse | GenericAckResponse | MissingFieldsErrorResponse | WebSocketTriggerEvent;
//# sourceMappingURL=index.d.ts.map