@chaterafrikang/sdk 0.1.0-beta.0

package/dist/index.d.cts

@@ -0,0 +1,1072 @@
+import { EventEmitter } from 'eventemitter3';
+
+/**
+ * Configuration options for the ChatAfrika SDK client
+ */
+interface ClientConfig {
+    /**
+     * WebSocket server URL
+     */
+    wsUrl: string;
+    /**
+     * REST API base URL (optional, for fallback operations)
+     */
+    apiUrl?: string;
+    /**
+     * SDK token for authentication
+     */
+    token: string;
+    /**
+     * Enable automatic reconnection
+     * @default true
+     */
+    autoReconnect?: boolean;
+    /**
+     * Maximum reconnection attempts
+     * @default 5
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Reconnection delay in milliseconds
+     * @default 1000
+     */
+    reconnectDelay?: number;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+}
+
+/**
+ * Connection state enumeration for the SDK
+ */
+declare enum ConnectionState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    ERROR = "error"
+}
+
+/**
+ * Manages SDK token storage and validation
+ *
+ * Note: This manager only CONSUMES tokens.
+ * Token issuance is handled by the backend API.
+ */
+declare class TokenManager {
+    private token;
+    /**
+     * Set the SDK token
+     */
+    setToken(token: string): void;
+    /**
+     * Get the current SDK token
+     */
+    getToken(): string | null;
+    /**
+     * Check if a token is set
+     */
+    hasToken(): boolean;
+    /**
+     * Clear the token
+     */
+    clearToken(): void;
+    /**
+     * Replace the current token with a new one (token rotation)
+     */
+    rotateToken(newToken: string): void;
+    /**
+     * Validate token format (basic validation)
+     */
+    isValidFormat(token: string): boolean;
+    /**
+     * Validate that a token is present before operations
+     */
+    validateTokenPresence(): void;
+}
+
+/**
+ * WebSocket message protocol matching the Go backend
+ */
+type ClientMessageType = 'join' | 'leave' | 'message' | 'typing_start' | 'typing_stop';
+/**
+ * Base structure for all client messages
+ */
+interface BaseClientMessage {
+    type: ClientMessageType;
+    conversation_id: string;
+}
+/**
+ * Join conversation message
+ */
+interface JoinMessage extends BaseClientMessage {
+    type: 'join';
+}
+/**
+ * Leave conversation message
+ */
+interface LeaveMessage extends BaseClientMessage {
+    type: 'leave';
+}
+/**
+ * Send message payload
+ */
+interface MessagePayload {
+    message_id: string;
+    content: string;
+    message_type: string;
+}
+/**
+ * Send message to conversation
+ */
+interface SendMessageMessage extends BaseClientMessage {
+    type: 'message';
+    payload: MessagePayload;
+}
+/**
+ * Typing start message
+ */
+interface TypingStartMessage extends BaseClientMessage {
+    type: 'typing_start';
+}
+/**
+ * Typing stop message
+ */
+interface TypingStopMessage extends BaseClientMessage {
+    type: 'typing_stop';
+}
+/**
+ * Union type for all client messages
+ */
+type ClientMessage = JoinMessage | LeaveMessage | SendMessageMessage | TypingStartMessage | TypingStopMessage;
+type ServerMessageType = 'joined' | 'message' | 'typing' | 'presence' | 'receipt' | 'support' | 'error';
+/**
+ * Base structure for all server messages
+ */
+interface BaseServerMessage {
+    type: ServerMessageType;
+    conversation_id?: string;
+}
+/**
+ * Joined conversation response
+ */
+interface JoinedMessage extends BaseServerMessage {
+    type: 'joined';
+    payload?: {
+        conversation_id: string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Broadcast message payload
+ */
+interface BroadcastMessagePayload {
+    message_id: string;
+    sender_id: string;
+    sender_type: string;
+    content: string;
+    message_type: string;
+    sent_at: string;
+}
+/**
+ * Received message from server
+ */
+interface ReceivedMessageMessage extends BaseServerMessage {
+    type: 'message';
+    conversation_id: string;
+    payload: BroadcastMessagePayload;
+}
+/**
+ * Typing indicator payload
+ */
+interface TypingPayload {
+    user_id: string;
+    state: 'start' | 'stop';
+}
+/**
+ * Typing indicator message
+ */
+interface TypingMessage extends BaseServerMessage {
+    type: 'typing';
+    conversation_id: string;
+    payload: TypingPayload;
+}
+/**
+ * Presence payload
+ */
+interface PresencePayload {
+    user_id: string;
+    state: 'online' | 'offline';
+}
+/**
+ * Presence update message
+ */
+interface PresenceMessage extends BaseServerMessage {
+    type: 'presence';
+    payload: PresencePayload;
+}
+/**
+ * Receipt payload
+ */
+interface ReceiptPayload {
+    message_id: string;
+    user_id?: string;
+    state: 'delivered' | 'read';
+}
+/**
+ * Receipt message from server
+ */
+interface ReceiptMessage extends BaseServerMessage {
+    type: 'receipt';
+    conversation_id: string;
+    payload: ReceiptPayload;
+}
+/**
+ * Support event type
+ */
+type SupportEventType = 'assigned' | 'unassigned' | 'bot_takeover' | 'bot_released' | 'closed' | 'reopened';
+/**
+ * Support event payload
+ */
+interface SupportEventPayload {
+    event: SupportEventType;
+    agent_id?: string;
+    [key: string]: unknown;
+}
+/**
+ * Support message from server
+ */
+interface SupportMessage extends BaseServerMessage {
+    type: 'support';
+    conversation_id: string;
+    payload: SupportEventPayload;
+}
+/**
+ * Error message from server
+ */
+interface ErrorMessage extends BaseServerMessage {
+    type: 'error';
+    error: string;
+}
+/**
+ * Union type for all server messages
+ */
+type ServerMessage = JoinedMessage | ReceivedMessageMessage | TypingMessage | PresenceMessage | ReceiptMessage | SupportMessage | ErrorMessage;
+
+/**
+ * Conversation class representing a single conversation
+ *
+ * This class provides a scoped API for conversation-level operations.
+ * It does NOT persist messages or store history.
+ */
+declare class Conversation extends EventEmitter {
+    readonly id: string;
+    private _isJoined;
+    private messageManager;
+    private typingManager;
+    /**
+     * Callback function to send messages via WebSocket
+     * Set by ConversationManager
+     */
+    private sendMessageHandler?;
+    /**
+     * Callback function to send typing events via WebSocket
+     * Set by ConversationManager
+     */
+    private sendTypingHandler?;
+    constructor(conversationId: string, debug?: boolean);
+    /**
+     * Check if this conversation is currently joined
+     */
+    get isJoined(): boolean;
+    /**
+     * Set the send message handler (called by ConversationManager)
+     */
+    setSendMessageHandler(handler: (message: SendMessageMessage) => void): void;
+    /**
+     * Set the send typing handler (called by ConversationManager)
+     */
+    setSendTypingHandler(handler: (message: TypingStartMessage | TypingStopMessage) => void): void;
+    /**
+     * Mark conversation as joined
+     */
+    markJoined(): void;
+    /**
+     * Mark conversation as left
+     */
+    markLeft(): void;
+    /**
+     * Send a message to this conversation
+     *
+     * This method:
+     * 1. Generates a message_id (UUID v4)
+     * 2. Creates an optimistic Message
+     * 3. Emits the optimistic message immediately
+     * 4. Sends the message via transport
+     */
+    sendMessage(content: string, messageType?: 'text' | 'system', metadata?: Record<string, unknown>): void;
+    /**
+     * Handle an incoming message from the server
+     * Called by ConversationManager when routing messages
+     */
+    handleIncomingMessage(payload: BroadcastMessagePayload): void;
+    /**
+     * Handle a receipt update
+     * Called by ConversationManager when routing receipt messages
+     */
+    handleReceipt(messageId: string, receiptState: 'delivered' | 'read', userId?: string): void;
+    /**
+     * Handle a typing event from the server
+     * Called by ConversationManager when routing typing messages
+     */
+    handleTyping(payload: TypingPayload): void;
+    /**
+     * Emit a presence event (called by ConversationManager when routing)
+     * Note: Presence is SDK-global, but we emit it here for convenience
+     */
+    emitPresence(payload: PresencePayload): void;
+    /**
+     * Clear message tracking for this conversation
+     */
+    clearMessages(): void;
+    /**
+     * Clear typing state for this conversation
+     */
+    clearTyping(): void;
+    /**
+     * Start typing indicator
+     *
+     * This method sends a typing_start message to the server.
+     * The TypingManager will handle debouncing and auto-expiry.
+     */
+    startTyping(): void;
+    /**
+     * Stop typing indicator
+     *
+     * This method sends a typing_stop message to the server.
+     */
+    stopTyping(): void;
+}
+
+/**
+ * Support session role
+ */
+type SupportRole = 'customer' | 'agent';
+/**
+ * Support session status
+ */
+type SupportStatus = 'queued' | 'assigned' | 'active' | 'closed';
+/**
+ * SupportSession wraps a Conversation and adds support-specific semantics
+ *
+ * This is a thin semantic layer that provides:
+ * - Role awareness (customer vs agent)
+ * - Assignment state tracking
+ * - Bot handover awareness
+ *
+ * It does NOT replace Conversation - it wraps it.
+ */
+declare class SupportSession extends EventEmitter {
+    readonly conversationId: string;
+    private conversation;
+    private role;
+    private assignedAgentId?;
+    private botActive;
+    private status;
+    private logger;
+    constructor(conversationId: string, conversation: Conversation, role: SupportRole, debug?: boolean);
+    /**
+     * Get the underlying Conversation instance
+     */
+    getConversation(): Conversation;
+    /**
+     * Check if this session is for a customer
+     */
+    isCustomer(): boolean;
+    /**
+     * Check if this session is for an agent
+     */
+    isAgent(): boolean;
+    /**
+     * Get the current role
+     */
+    getRole(): SupportRole;
+    /**
+     * Check if bot is currently active
+     */
+    isBotActive(): boolean;
+    /**
+     * Get the assigned agent ID (if any)
+     */
+    getAssignedAgent(): string | undefined;
+    /**
+     * Get the current status
+     */
+    getStatus(): SupportStatus;
+    /**
+     * Handle assignment of an agent
+     */
+    handleAssigned(agentId: string): void;
+    /**
+     * Handle unassignment of an agent
+     */
+    handleUnassigned(): void;
+    /**
+     * Handle bot takeover
+     */
+    handleBotTakeover(): void;
+    /**
+     * Handle bot release
+     */
+    handleBotReleased(): void;
+    /**
+     * Handle session closed
+     */
+    handleClosed(): void;
+    /**
+     * Handle session reopened
+     */
+    handleReopened(): void;
+    /**
+     * Send a message (delegates to Conversation)
+     */
+    sendMessage(content: string, messageType?: 'text' | 'system', metadata?: Record<string, unknown>): void;
+    /**
+     * Join the conversation (delegates to Conversation)
+     */
+    join(): Promise<void>;
+    /**
+     * Leave the conversation (delegates to Conversation)
+     */
+    leave(): Promise<void>;
+}
+
+/**
+ * Main ChatAfrika SDK class
+ *
+ * This is the primary entry point for the SDK.
+ * It manages the connection state and provides access to all SDK features.
+ */
+declare class ChatAfrika extends EventEmitter {
+    private config;
+    private connectionState;
+    private wsClient;
+    private tokenManager;
+    private conversationManager;
+    private presenceManager;
+    private supportManager;
+    private logger;
+    constructor(config: ClientConfig);
+    /**
+     * Set up WebSocket event handlers
+     */
+    private setupWebSocketHandlers;
+    /**
+     * Get the current connection state
+     */
+    getState(): ConnectionState;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): Readonly<Required<ClientConfig>>;
+    /**
+     * Connect to the ChatAfrika service
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the ChatAfrika service
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Check if the client is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Update the authentication token
+     * Use this when your token expires and you need to refresh it
+     * After updating, call connect() to reconnect with the new token
+     */
+    updateToken(newToken: string): void;
+    /**
+     * Get the conversations manager
+     * Exposes: sdk.conversations.get(id), sdk.conversations.join(id), etc.
+     */
+    get conversations(): {
+        get: (id: string) => Conversation;
+        has: (id: string) => boolean;
+        join: (id: string) => Promise<void>;
+        leave: (id: string) => Promise<void>;
+    };
+    /**
+     * Get the support manager
+     * Exposes: sdk.support.get(conversationId, role?)
+     */
+    get support(): {
+        get: (id: string, role?: 'customer' | 'agent') => SupportSession;
+        has: (id: string) => boolean;
+    };
+    /**
+     * Join a conversation room (internal method used by ConversationManager)
+     */
+    private joinConversation;
+    /**
+     * Leave a conversation room (internal method used by ConversationManager)
+     */
+    private leaveConversation;
+    /**
+     * Rotate the authentication token
+     */
+    rotateToken(newToken: string): void;
+    /**
+     * Get the token manager (for advanced use cases)
+     */
+    getTokenManager(): TokenManager;
+}
+
+/**
+ * Manages Conversation instances and routes incoming protocol messages
+ */
+declare class ConversationManager extends EventEmitter {
+    private conversations;
+    private sendMessageHandler?;
+    private sendTypingHandler?;
+    private supportMessageHandler?;
+    private logger;
+    private debug;
+    constructor(sendMessageHandler: (message: SendMessageMessage) => void, debug?: boolean, supportMessageHandler?: (conversationId: string, eventType: string, payload?: Record<string, unknown>) => void, sendTypingHandler?: (message: TypingStartMessage | TypingStopMessage) => void);
+    /**
+     * Set the support message handler (called by ChatAfrika)
+     */
+    setSupportMessageHandler(handler: (conversationId: string, eventType: string, payload?: Record<string, unknown>) => void): void;
+    /**
+     * Set the send typing handler (called by ChatAfrika)
+     */
+    setSendTypingHandler(handler: (message: TypingStartMessage | TypingStopMessage) => void): void;
+    /**
+     * Get or create a Conversation instance
+     * Conversations are lazy-created
+     */
+    get(conversationId: string): Conversation;
+    /**
+     * Check if a conversation instance exists
+     */
+    has(conversationId: string): boolean;
+    /**
+     * Join a conversation
+     * This delegates to the transport layer (ChatAfrika)
+     */
+    join(conversationId: string, joinHandler: (conversationId: string) => Promise<void>): Promise<void>;
+    /**
+     * Leave a conversation
+     * This delegates to the transport layer (ChatAfrika)
+     */
+    leave(conversationId: string, leaveHandler: (conversationId: string) => Promise<void>): Promise<void>;
+    /**
+     * Route an incoming protocol message to the appropriate Conversation
+     *
+     * Messages are routed through MessageManager for lifecycle handling.
+     * Typing events are routed through TypingManager.
+     * Only messages for joined conversations are processed.
+     */
+    routeIncomingMessage(message: ServerMessage): void;
+    /**
+     * Route a support protocol message to SupportManager
+     */
+    routeSupportMessage(message: SupportMessage): void;
+    /**
+     * Remove a conversation instance
+     */
+    remove(conversationId: string): void;
+    /**
+     * Get all conversation IDs
+     */
+    getAllIds(): string[];
+    /**
+     * Clear all conversations
+     */
+    clear(): void;
+}
+
+/**
+ * Receipt state enumeration (monotonic progression)
+ */
+type ReceiptState$1 = 'sent' | 'delivered' | 'read';
+/**
+ * Message model with lifecycle awareness
+ */
+interface Message {
+    id: string;
+    conversationId: string;
+    content: string;
+    senderId?: string;
+    senderType?: 'user' | 'sdk' | 'bot';
+    messageType: 'text' | 'system';
+    createdAt?: Date;
+    optimistic: boolean;
+    receiptState?: ReceiptState$1;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Static helpers for Message creation
+ */
+declare class MessageFactory {
+    /**
+     * Create an optimistic message (client-generated, not yet confirmed by server)
+     */
+    static createOptimistic(conversationId: string, messageId: string, content: string, messageType?: 'text' | 'system', metadata?: Record<string, unknown>): Message;
+    /**
+     * Create a message from server payload (confirmed message)
+     */
+    static fromServerPayload(conversationId: string, payload: BroadcastMessagePayload): Message;
+    /**
+     * Convert an optimistic message to confirmed (reconciliation)
+     */
+    static confirmOptimistic(optimisticMessage: Message, serverPayload: BroadcastMessagePayload): Message;
+    /**
+     * Update receipt state on a message (immutable update)
+     */
+    static updateReceiptState(message: Message, receiptState: ReceiptState$1): Message;
+}
+
+/**
+ * Manages message lifecycle: optimistic messages, deduplication, and reconciliation
+ *
+ * This manager does NOT store message history.
+ * It only tracks message IDs for deduplication and optimistic messages for reconciliation.
+ */
+declare class MessageManager extends EventEmitter {
+    /**
+     * Track seen message IDs per conversation to prevent duplicates
+     * Map<conversationId, Set<message_id>>
+     */
+    private seenMessageIds;
+    /**
+     * Track optimistic messages that are waiting for server confirmation
+     * Map<conversationId, Map<message_id, Message>>
+     */
+    private optimisticMessages;
+    /**
+     * Track confirmed messages for receipt updates
+     * Map<conversationId, Map<message_id, Message>>
+     */
+    private confirmedMessages;
+    /**
+     * Receipt manager for handling receipt lifecycle
+     */
+    private receiptManager;
+    private logger;
+    constructor(debug?: boolean);
+    /**
+     * Create an optimistic message and emit it immediately
+     *
+     * @returns The created optimistic message
+     */
+    createOptimisticMessage(conversationId: string, messageId: string, content: string, messageType?: 'text' | 'system', metadata?: Record<string, unknown>): Message;
+    /**
+     * Handle an incoming message from the server
+     *
+     * This method:
+     * - Checks for duplicates
+     * - Reconciles optimistic messages if message_id matches
+     * - Emits confirmed messages
+     *
+     * @returns The message (reconciled if optimistic, new if not), or null if duplicate
+     */
+    handleIncomingMessage(conversationId: string, serverPayload: BroadcastMessagePayload): Message | null;
+    /**
+     * Handle a receipt update
+     *
+     * This method:
+     * - Routes receipt to ReceiptManager
+     * - Updates message receipt state if message exists
+     * - Emits updated message
+     */
+    handleReceipt(_conversationId: string, messageId: string, receiptState: 'delivered' | 'read', userId?: string): void;
+    /**
+     * Update message receipt state and emit updated message
+     */
+    private updateMessageReceiptState;
+    /**
+     * Reconcile an optimistic message with a server confirmation
+     *
+     * This is called when we receive a server message with the same message_id
+     * as an optimistic message we previously created.
+     *
+     * @returns The reconciled (confirmed) message
+     */
+    private reconcileOptimisticMessage;
+    /**
+     * Check if we've already seen a message ID for a conversation
+     */
+    hasSeenMessage(conversationId: string, messageId: string): boolean;
+    /**
+     * Track a message ID for a conversation (for deduplication)
+     */
+    private trackMessageId;
+    /**
+     * Track an optimistic message for later reconciliation
+     */
+    private trackOptimisticMessage;
+    /**
+     * Get an optimistic message by ID
+     */
+    private getOptimisticMessage;
+    /**
+     * Remove an optimistic message from tracking
+     */
+    private removeOptimisticMessage;
+    /**
+     * Track a confirmed message for receipt updates
+     */
+    private trackConfirmedMessage;
+    /**
+     * Get all message IDs for a conversation (for receipt clearing)
+     */
+    getMessageIds(conversationId: string): string[];
+    /**
+     * Clear tracked message IDs and optimistic messages for a conversation
+     */
+    clearConversation(conversationId: string): void;
+    /**
+     * Clear all tracked message IDs and optimistic messages
+     */
+    clear(): void;
+}
+
+/**
+ * Presence event payload
+ */
+interface PresenceEvent {
+    userId: string;
+    state: 'online' | 'offline';
+}
+/**
+ * Manages user presence with state tracking and deduplication
+ *
+ * This manager:
+ * - Tracks presence state per user (SDK-global, not conversation-scoped)
+ * - Emits only on state changes
+ * - Deduplicates duplicate events
+ */
+declare class PresenceManager extends EventEmitter {
+    /**
+     * Track current presence state per user
+     * Map<userId, "online" | "offline">
+     */
+    private presenceState;
+    private logger;
+    constructor(debug?: boolean);
+    /**
+     * Handle a presence event
+     *
+     * Rules:
+     * - Emit only on state change
+     * - Ignore duplicate online/online or offline/offline events
+     */
+    handlePresence(userId: string, state: 'online' | 'offline'): void;
+    /**
+     * Get current presence state for a user
+     */
+    getPresence(userId: string): 'online' | 'offline' | undefined;
+    /**
+     * Get presence state for multiple users
+     */
+    getPresences(userIds: string[]): Map<string, 'online' | 'offline'>;
+    /**
+     * Clear presence for a user
+     */
+    clearPresence(userId: string): void;
+    /**
+     * Clear all presence state
+     */
+    clear(): void;
+}
+
+/**
+ * Typing event payload
+ */
+interface TypingEvent {
+    conversationId: string;
+    userId: string;
+    state: 'start' | 'stop';
+}
+/**
+ * Manages typing indicators with automatic lifecycle management
+ *
+ * This manager:
+ * - Tracks typing state per conversation per user
+ * - Automatically expires typing after 5 seconds
+ * - Prevents duplicate events
+ * - Emits clean, minimal events
+ */
+declare class TypingManager extends EventEmitter {
+    /**
+     * Track active typing timers per conversation per user
+     * Map<conversationId, Map<userId, timeout>>
+     */
+    private typingTimers;
+    /**
+     * Track who is currently typing per conversation
+     * Map<conversationId, Set<userId>>
+     */
+    private activeTyping;
+    private logger;
+    private readonly TYPING_TIMEOUT_MS;
+    constructor(debug?: boolean);
+    /**
+     * Handle a typing_start event
+     *
+     * Rules:
+     * - Emit only once per user until stopped
+     * - Restart timeout if typing_start repeats
+     */
+    handleTypingStart(conversationId: string, userId: string): void;
+    /**
+     * Handle a typing_stop event
+     *
+     * Rules:
+     * - Emit only if user was typing
+     */
+    handleTypingStop(conversationId: string, userId: string): void;
+    /**
+     * Clear all typing state for a conversation
+     */
+    clearConversation(conversationId: string): void;
+    /**
+     * Clear all typing state
+     */
+    clear(): void;
+    /**
+     * Get currently typing users for a conversation
+     */
+    getTypingUsers(conversationId: string): string[];
+}
+
+/**
+ * Receipt state enumeration (monotonic progression)
+ *
+ * Note: This is also exported from messages/Message.ts for consistency
+ */
+type ReceiptState = 'sent' | 'delivered' | 'read';
+/**
+ * Receipt event payload
+ */
+interface ReceiptEvent {
+    messageId: string;
+    state: 'delivered' | 'read';
+    userId?: string;
+}
+/**
+ * Manages receipt lifecycle with monotonic state transitions
+ *
+ * This manager:
+ * - Tracks receipt state per message
+ * - Enforces valid state transitions (sent → delivered → read)
+ * - Deduplicates receipt events
+ * - Emits only meaningful transitions
+ */
+declare class ReceiptManager extends EventEmitter {
+    /**
+     * Track receipt state per message
+     * Map<messageId, ReceiptState>
+     */
+    private receiptState;
+    private logger;
+    constructor(debug?: boolean);
+    /**
+     * Get receipt state for a message
+     */
+    getReceiptState(messageId: string): ReceiptState | undefined;
+    /**
+     * Handle a delivered receipt
+     *
+     * Rules:
+     * - Only update if current state < delivered
+     * - Ignore duplicate or regressive updates
+     */
+    handleDelivered(messageId: string, userId?: string): boolean;
+    /**
+     * Handle a read receipt
+     *
+     * Rules:
+     * - Only update if current state < read
+     * - Ignore duplicate or regressive updates
+     */
+    handleRead(messageId: string, userId?: string): boolean;
+    /**
+     * Compare two receipt states
+     * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+     */
+    private compareStates;
+    /**
+     * Clear receipt state for a conversation
+     * Note: We track by messageId, so we need to clear all messages for a conversation
+     * This is called when leaving a conversation
+     */
+    clearConversation(conversationId: string, messageIds: string[]): void;
+    /**
+     * Clear receipt state for a specific message
+     */
+    clearMessage(messageId: string): void;
+    /**
+     * Clear all receipt state
+     */
+    clear(): void;
+}
+
+/**
+ * Manages SupportSession instances
+ *
+ * This manager:
+ * - Creates SupportSession instances lazily
+ * - Tracks support sessions by conversation ID
+ * - Provides role-aware access to support conversations
+ */
+declare class SupportManager extends EventEmitter {
+    private sessions;
+    private getConversationHandler;
+    private logger;
+    private debug;
+    constructor(getConversationHandler: (conversationId: string) => Conversation, debug?: boolean);
+    /**
+     * Get or create a SupportSession for a conversation
+     *
+     * Note: This assumes the conversation is a support conversation.
+     * The role is determined by the SDK user's context (not inferred).
+     *
+     * @param conversationId - The conversation ID
+     * @param role - The role of the current user ('customer' or 'agent')
+     * @returns SupportSession instance
+     */
+    get(conversationId: string, role?: SupportRole): SupportSession;
+    /**
+     * Check if a support session exists
+     */
+    has(conversationId: string): boolean;
+    /**
+     * Get a support session if it exists
+     */
+    getSession(conversationId: string): SupportSession | undefined;
+    /**
+     * Handle a support protocol event
+     */
+    handleSupportEvent(conversationId: string, eventType: 'assigned' | 'unassigned' | 'bot_takeover' | 'bot_released' | 'closed' | 'reopened', payload?: Record<string, unknown>): void;
+    /**
+     * Remove a support session
+     */
+    remove(conversationId: string): void;
+    /**
+     * Clear all support sessions
+     */
+    clear(): void;
+}
+
+/**
+ * Low-level WebSocket client for handling connections
+ */
+declare class WebSocketClient extends EventEmitter {
+    private ws;
+    private url;
+    private token;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private autoReconnect;
+    private reconnectTimer;
+    private isManuallyDisconnected;
+    private isTokenExpired;
+    private logger;
+    constructor(url: string, options?: {
+        autoReconnect?: boolean;
+        maxReconnectAttempts?: number;
+        reconnectDelay?: number;
+        debug?: boolean;
+    });
+    /**
+     * Connect to the WebSocket server with authentication token
+     */
+    connect(token: string): Promise<void>;
+    /**
+     * Attempt a WebSocket connection
+     */
+    private attemptConnection;
+    /**
+     * Set up WebSocket event handlers
+     */
+    private setupEventHandlers;
+    /**
+     * Handle token expiration - stop reconnection attempts
+     */
+    private handleTokenExpiration;
+    /**
+     * Disconnect from the WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Send a message to the server
+     */
+    send(message: ClientMessage): void;
+    /**
+     * Check if the WebSocket is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get current reconnection attempt count
+     */
+    getReconnectAttempts(): number;
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     * Backoff: 1s → 2s → 5s → 10s (max)
+     */
+    private scheduleReconnect;
+}
+
+/**
+ * Simple logger utility
+ */
+declare class Logger {
+    private enabled;
+    constructor(enabled?: boolean);
+    setEnabled(enabled: boolean): void;
+    debug(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+}
+
+/**
+ * Retry utility for async operations
+ */
+interface RetryOptions {
+    maxAttempts?: number;
+    delay?: number;
+    backoff?: boolean;
+    onRetry?: (attempt: number, error: Error) => void;
+}
+/**
+ * Retry an async function with exponential backoff
+ */
+declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+
+/**
+ * Type guards and validation utilities
+ */
+/**
+ * Check if a value is a non-empty string
+ */
+declare function isNonEmptyString(value: unknown): value is string;
+/**
+ * Check if a value is a valid URL string
+ */
+declare function isValidUrl(value: unknown): value is string;
+/**
+ * Check if a value is a number
+ */
+declare function isNumber(value: unknown): value is number;
+/**
+ * Check if a value is a positive integer
+ */
+declare function isPositiveInteger(value: unknown): value is number;
+
+export { type BroadcastMessagePayload, ChatAfrika, type ClientConfig, type ClientMessage, type ClientMessageType, ConnectionState, Conversation, ConversationManager, type ErrorMessage, type JoinMessage, type JoinedMessage, type LeaveMessage, Logger, type Message, MessageFactory, MessageManager, type MessagePayload, type PresenceEvent, PresenceManager, type PresenceMessage, type PresencePayload, type ReceiptEvent, ReceiptManager, type ReceiptMessage, type ReceiptPayload, type ReceiptState$1 as ReceiptState, type ReceivedMessageMessage, type RetryOptions, type SendMessageMessage, type ServerMessage, type ServerMessageType, type SupportEventPayload, type SupportEventType, SupportManager, type SupportMessage, type SupportRole, SupportSession, type SupportStatus, TokenManager, type TypingEvent, TypingManager, type TypingMessage, type TypingPayload, type TypingStartMessage, type TypingStopMessage, WebSocketClient, isNonEmptyString, isNumber, isPositiveInteger, isValidUrl, retry };