ajaxter-chat 3.1.0 → 3.2.0

package/src/config/index.ts

@@ -1,56 +1,117 @@
-import { LocalEnvConfig, RemoteChatData } from '../types';
+import { LocalEnvConfig, RemoteChatData, AjaxterConfigResponse, WidgetConfig } from '../types';
 
-/**
- * Default JSON endpoint. Override with `REACT_APP_CHAT_CONFIG_URL` / `NEXT_PUBLIC_CHAT_CONFIG_URL`.
- * If the remote host does not send CORS headers, set this to a same-origin path (e.g. `/api/chat-config`)
- * and proxy the JSON from your server — see `examples/next-app-router-chat-proxy.ts`.
- */
-const DEFAULT_CHAT_DATA_BASE = 'https://window.mscorpres.com/TEST/chatData.json';
-const DEMO_API_KEY   = 'demo1234';
-const DEMO_WIDGET_ID = 'demo';
+const DEFAULT_SOCKET_URL = 'http://localhost:3005';
+const DEFAULT_CONFIG_URL = 'http://localhost:5000/api/chat-config';
+const DEMO_API_KEY       = 'demo1234';
+const DEMO_WIDGET_ID     = 'demo';
 
 function getEnv(key: string): string | undefined {
   if (typeof process !== 'undefined' && process.env) {
     return (
       process.env[`NEXT_PUBLIC_${key}`] ??
-      process.env[`REACT_APP_${key}`] ??
-      process.env[key] ??
+      process.env[`REACT_APP_${key}`]   ??
+      process.env[key]                   ??
       undefined
     );
   }
   return undefined;
 }
 
-function getChatDataBaseUrl(): string {
-  return getEnv('CHAT_CONFIG_URL')?.trim() || DEFAULT_CHAT_DATA_BASE;
+export function loadLocalConfig(): LocalEnvConfig {
+  return {
+    apiKey:    getEnv('CHAT_API_KEY')    ?? DEMO_API_KEY,
+    widgetId:  getEnv('CHAT_WIDGET_ID') ?? DEMO_WIDGET_ID,
+    socketUrl: getEnv('SOCKET_URL')     ?? DEFAULT_SOCKET_URL,
+  };
+}
+
+function getConfigUrl(): string {
+  return getEnv('CHAT_CONFIG_URL')?.trim() ?? DEFAULT_CONFIG_URL;
 }
 
 /**
- * Loads remote widget config once via GET. Uses query params `key` and `widget` so the
- * server can validate the request without custom headers (avoids CORS preflight failures).
+ * Fetches widget config ONCE from the server.
+ * URL: GET /api/chat-config?key=<apiKey>&widget=<widgetId>
+ *
+ * Returns RemoteChatData (the shape the widget components expect),
+ * translated from the Ajaxter server response format.
  */
 export async function fetchRemoteChatData(
   apiKey: string,
   widgetId: string
 ): Promise<RemoteChatData> {
-  const base = getChatDataBaseUrl();
-  const url = new URL(base, typeof window !== 'undefined' ? window.location.origin : 'https://localhost');
-  url.searchParams.set('key', apiKey);
+  const base = getConfigUrl();
+  const url  = new URL(
+    base,
+    typeof window !== 'undefined' ? window.location.origin : 'http://localhost'
+  );
+  url.searchParams.set('key',    apiKey);
   url.searchParams.set('widget', widgetId);
 
   const res = await fetch(url.toString(), {
-    method: 'GET',
+    method:  'GET',
+    headers: { Accept: 'application/json' },
     credentials: 'omit',
     mode: 'cors',
-    headers: { Accept: 'application/json' },
   });
-  if (!res.ok) throw new Error(`Failed to load chat config: ${res.status}`);
-  return res.json() as Promise<RemoteChatData>;
-}
 
-export function loadLocalConfig(): LocalEnvConfig {
+  if (!res.ok) throw new Error(`Chat config fetch failed: ${res.status}`);
+
+  const json = await res.json() as AjaxterConfigResponse;
+
+  if (!json.ok || !json.data) {
+    throw new Error('Invalid config response from server');
+  }
+
+  const { data } = json;
+  const internal = data._internal;
+  const ws       = data.widget;
+
+  // Map Ajaxter server response → WidgetConfig used by components
+  const widgetConfig: WidgetConfig = {
+    id:          internal.id,
+    apiKey:      internal.apiKey,
+    status:      internal.status,
+    chatType:    internal.chatType,
+    displayMode: internal.displayMode,
+    primaryColor: internal.primaryColor,
+    buttonLabel:  internal.buttonLabel,
+
+    // Button position from visibility config
+    buttonPosition: (ws.visibility?.mobile?.position === 'bottom-left'
+      ? 'bottom-left'
+      : 'bottom-right') as 'bottom-right' | 'bottom-left',
+
+    // Welcome text from states.online header
+    welcomeTitle:    data.branding?.name ?? internal.brandName ?? 'Hello there 👋',
+    welcomeSubtitle: (ws.states as Record<string, { header?: Array<{content?: {value?: string}}> }> | undefined)
+      ?.online?.header?.[0]?.content?.value
+      ?? 'How can we help you today?',
+
+    brandName:           internal.brandName ?? undefined,
+    supportPhone:        internal.supportPhone ?? undefined,
+    privacyPolicyUrl:    internal.privacyPolicyUrl ?? undefined,
+    showPrivacyNotice:   internal.showPrivacyNotice,
+
+    allowVoiceMessage:   internal.allowVoiceMessage,
+    allowAttachment:     internal.allowAttachment,
+    allowEmoji:          internal.allowEmoji,
+    allowWebCall:        internal.allowWebCall,
+    maxEmojiCount:       internal.maxEmojiCount,
+    allowTranscriptDownload: internal.allowTranscript,
+    allowReport:         internal.allowReport,
+    allowBlock:          internal.allowBlock,
+
+    // Full Ajaxter settings stored for display-mode rendering
+    ajaxterSettings: ws,
+  };
+
   return {
-    apiKey:   getEnv('CHAT_API_KEY')    ?? DEMO_API_KEY,
-    widgetId: getEnv('CHAT_WIDGET_ID')  ?? DEMO_WIDGET_ID,
+    widget:       widgetConfig,
+    developers:   data.developers   ?? [],
+    users:        data.users        ?? [],
+    sampleChats:  data.sampleChats  ?? {},
+    sampleTickets: data.sampleTickets ?? [],
+    blockedUsers: data.blockedUsers ?? [],
   };
 }

package/src/hooks/useRemoteConfig.ts

@@ -8,17 +8,22 @@ export function useRemoteConfig(apiKey: string, widgetId: string) {
   const [error,   setError]   = useState<string | null>(null);
 
   useEffect(() => {
+    if (!apiKey || !widgetId) return;
     let cancelled = false;
     setLoading(true);
+    setError(null);
+
     fetchRemoteChatData(apiKey, widgetId)
-      .then(d  => { if (!cancelled) { setData(d); setError(null); setLoading(false); } })
+      .then(d => {
+        if (!cancelled) { setData(d); setLoading(false); }
+      })
       .catch(e => {
         if (!cancelled) {
-          const msg = e instanceof Error ? e.message : String(e);
-          setError(msg || 'Network error while loading configuration');
+          setError(e instanceof Error ? e.message : 'Failed to load config');
           setLoading(false);
         }
       });
+
     return () => { cancelled = true; };
   }, [apiKey, widgetId]);
 

package/src/hooks/useSocket.ts

@@ -1,5 +1,15 @@
 'use client';
 
+/**
+ * useSocket — wraps socket.io-client for the ajaxter-chat npm package.
+ *
+ * The npm package fetches widget config ONCE via HTTP (GET /api/chat-config),
+ * then all real-time events (messages, calls, typing, presence…) flow through
+ * this Socket.IO connection.
+ *
+ * Install peer dep in consumer app:  npm install socket.io-client
+ */
+
 import { useEffect, useRef, useCallback, useState } from 'react';
 import { ChatMessage } from '../types';
 
@@ -11,218 +21,229 @@ export interface SocketMessageAck {
 }
 
 export interface UseSocketOptions {
-  widgetId: string;
-  viewerUid: string;
-  /** WebSocket server URL — defaults to http://localhost:3005 */
+  widgetId:   string;
+  viewerUid:  string;
+  /** Socket.IO server URL — defaults to http://localhost:3005 */
   serverUrl?: string;
-  onMessage?: (msg: ChatMessage) => void;
-  onMessageAck?: (ack: SocketMessageAck) => void;
-  onChatPaused?: (roomId: string, paused: boolean) => void;
-  onCallOffer?: (offer: RTCSessionDescriptionInit, fromUid: string, callId: string) => void;
-  onCallAnswer?: (answer: RTCSessionDescriptionInit, fromUid: string, callId: string) => void;
-  onIceCandidate?: (candidate: RTCIceCandidateInit, fromUid: string) => void;
-  onCallEnd?: (callId: string) => void;
-  onError?: (code: string, message: string) => void;
-  onUserStatus?: (uid: string, status: 'online' | 'away' | 'offline') => void;
+  onMessage?:     (msg: ChatMessage) => void;
+  onMessageAck?:  (ack: SocketMessageAck) => void;
+  onChatPaused?:  (roomId: string, paused: boolean) => void;
+  onCallOffer?:   (offer: RTCSessionDescriptionInit, fromUid: string, callId: string) => void;
+  onCallAnswer?:  (answer: RTCSessionDescriptionInit, fromUid: string, callId: string) => void;
+  onIceCandidate?:(candidate: RTCIceCandidateInit, fromUid: string) => void;
+  onCallEnd?:     (callId: string) => void;
+  onTypingStart?: (roomId: string, userId: string) => void;
+  onTypingStop?:  (roomId: string, userId: string) => void;
+  onUserStatus?:  (uid: string, status: 'online' | 'away' | 'offline') => void;
+  onTicketCreated?: (ticket: unknown) => void;
+  onTicketUpdated?: (ticket: unknown) => void;
+  onTransferAssigned?: (payload: unknown) => void;
+  onError?:       (code: string, message: string) => void;
+}
+
+// Lazy-load socket.io-client so the package stays light when not connected
+type SocketIO = {
+  on:         (event: string, cb: (...args: unknown[]) => void) => void;
+  off:        (event: string, cb?: (...args: unknown[]) => void) => void;
+  emit:       (event: string, data?: unknown) => void;
+  disconnect: () => void;
+  connected:  boolean;
+};
+
+async function createSocket(url: string, query: Record<string, string>): Promise<SocketIO> {
+  // Dynamic import so bundle is not broken when socket.io-client is absent
+  // Consumer app must have socket.io-client installed
+  let io: (url: string, opts: unknown) => SocketIO;
+  try {
+    const mod = await import('socket.io-client' as string);
+    io = (mod.default || mod) as (url: string, opts: unknown) => SocketIO;
+  } catch {
+    throw new Error(
+      '[ajaxter-chat] socket.io-client not found. ' +
+      'Run: npm install socket.io-client'
+    );
+  }
+  return io(url, {
+    query,
+    transports:       ['websocket', 'polling'],
+    reconnection:     true,
+    reconnectionDelay: 2000,
+    reconnectionAttempts: 10,
+    autoConnect:      true,
+  });
 }
 
-const SOCKET_URL = 'http://localhost:3005';
-const RECONNECT_DELAY = 3000;
-const MAX_RECONNECT = 5;
+const DEFAULT_SOCKET_URL = 'http://localhost:3005';
 
 export function useSocket(opts: UseSocketOptions) {
   const {
-    widgetId, viewerUid, serverUrl = SOCKET_URL,
+    widgetId, viewerUid,
+    serverUrl = DEFAULT_SOCKET_URL,
     onMessage, onMessageAck, onChatPaused,
     onCallOffer, onCallAnswer, onIceCandidate, onCallEnd,
-    onError, onUserStatus,
+    onTypingStart, onTypingStop, onUserStatus,
+    onTicketCreated, onTicketUpdated, onTransferAssigned, onError,
   } = opts;
 
   const [status, setStatus] = useState<SocketStatus>('disconnected');
-  const wsRef = useRef<WebSocket | null>(null);
-  const reconnectCount = useRef(0);
-  const reconnectTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
-  const currentRoomRef = useRef<string | null>(null);
-  const mountedRef = useRef(true);
-
-  const send = useCallback((event: string, payload: unknown) => {
-    if (wsRef.current?.readyState === WebSocket.OPEN) {
-      wsRef.current.send(JSON.stringify({ event, payload }));
+  const socketRef    = useRef<SocketIO | null>(null);
+  const mountedRef   = useRef(true);
+  const currentRoom  = useRef<string | null>(null);
+
+  // Stable emit helper
+  const emit = useCallback((event: string, data?: unknown) => {
+    if (socketRef.current?.connected) {
+      socketRef.current.emit(event, data);
     }
   }, []);
 
-  const connect = useCallback(() => {
-    if (!mountedRef.current) return;
-    if (wsRef.current) {
-      wsRef.current.onclose = null;
-      wsRef.current.close();
-    }
+  useEffect(() => {
+    if (!widgetId || !viewerUid) return;
+    mountedRef.current = true;
     setStatus('connecting');
 
-    const url = `${serverUrl}?widgetId=${encodeURIComponent(widgetId)}&uid=${encodeURIComponent(viewerUid)}`;
-    let ws: WebSocket;
-    try {
-      ws = new WebSocket(url);
-    } catch (e) {
-      setStatus('error');
-      return;
-    }
-    wsRef.current = ws;
-
-    ws.onopen = () => {
-      if (!mountedRef.current) { ws.close(); return; }
-      reconnectCount.current = 0;
-      setStatus('connected');
-      // Re-join current room if we were in one
-      if (currentRoomRef.current) {
-        send('join', { roomId: currentRoomRef.current, widgetId });
-      }
-    };
+    createSocket(serverUrl, { widgetId, uid: viewerUid }).then(socket => {
+      if (!mountedRef.current) { socket.disconnect(); return; }
+      socketRef.current = socket;
 
-    ws.onmessage = (event) => {
-      let parsed: { event: string; payload: unknown };
-      try { parsed = JSON.parse(event.data as string); }
-      catch { return; }
-      const { event: ev, payload } = parsed;
-      switch (ev) {
-        case 'message':
-          onMessage?.(payload as ChatMessage);
-          break;
-        case 'message:ack':
-          onMessageAck?.(payload as SocketMessageAck);
-          break;
-        case 'chat:paused': {
-          const p = payload as { roomId: string; paused: boolean };
-          onChatPaused?.(p.roomId, p.paused);
-          break;
-        }
-        case 'call-offer': {
-          const p = payload as { offer: RTCSessionDescriptionInit; from: string; callId: string };
-          onCallOffer?.(p.offer, p.from, p.callId);
-          break;
-        }
-        case 'call-answer': {
-          const p = payload as { answer: RTCSessionDescriptionInit; from: string; callId: string };
-          onCallAnswer?.(p.answer, p.from, p.callId);
-          break;
-        }
-        case 'ice-candidate': {
-          const p = payload as { candidate: RTCIceCandidateInit; from: string };
-          onIceCandidate?.(p.candidate, p.from);
-          break;
-        }
-        case 'call-end': {
-          const p = payload as { callId: string };
-          onCallEnd?.(p.callId);
-          break;
+      socket.on('connect', () => {
+        if (!mountedRef.current) return;
+        setStatus('connected');
+        // Rejoin current room after reconnect
+        if (currentRoom.current) {
+          socket.emit('join', { roomId: currentRoom.current, widgetId });
         }
-        case 'user:status': {
-          const p = payload as { uid: string; status: 'online' | 'away' | 'offline' };
-          onUserStatus?.(p.uid, p.status);
-          break;
-        }
-        case 'error': {
-          const p = payload as { code: string; message: string };
-          onError?.(p.code, p.message);
-          break;
-        }
-      }
-    };
-
-    ws.onerror = () => {
-      if (!mountedRef.current) return;
-      setStatus('error');
-    };
-
-    ws.onclose = () => {
-      if (!mountedRef.current) return;
-      setStatus('disconnected');
-      if (reconnectCount.current < MAX_RECONNECT) {
-        reconnectCount.current++;
-        reconnectTimer.current = setTimeout(connect, RECONNECT_DELAY * reconnectCount.current);
-      }
-    };
-  }, [widgetId, viewerUid, serverUrl, send, onMessage, onMessageAck, onChatPaused, onCallOffer, onCallAnswer, onIceCandidate, onCallEnd, onError, onUserStatus]);
+      });
+
+      socket.on('disconnect', () => {
+        if (mountedRef.current) setStatus('disconnected');
+      });
+
+      socket.on('connect_error', () => {
+        if (mountedRef.current) setStatus('error');
+      });
+
+      socket.on('message',     (msg: unknown) => onMessage?.(msg as ChatMessage));
+      socket.on('message:ack', (ack: unknown) => onMessageAck?.(ack as SocketMessageAck));
+
+      socket.on('chat:paused', (p: unknown) => {
+        const { roomId, paused } = p as { roomId: string; paused: boolean };
+        onChatPaused?.(roomId, paused);
+      });
+
+      socket.on('call-offer', (p: unknown) => {
+        const { offer, from, callId } = p as { offer: RTCSessionDescriptionInit; from: string; callId: string };
+        onCallOffer?.(offer, from, callId);
+      });
+      socket.on('call-answer', (p: unknown) => {
+        const { answer, from, callId } = p as { answer: RTCSessionDescriptionInit; from: string; callId: string };
+        onCallAnswer?.(answer, from, callId);
+      });
+      socket.on('ice-candidate', (p: unknown) => {
+        const { candidate, from } = p as { candidate: RTCIceCandidateInit; from: string };
+        onIceCandidate?.(candidate, from);
+      });
+      socket.on('call-end', (p: unknown) => {
+        const { callId } = p as { callId: string };
+        onCallEnd?.(callId);
+      });
+
+      socket.on('typing_start', (p: unknown) => {
+        const { roomId, userId } = p as { roomId: string; userId: string };
+        onTypingStart?.(roomId, userId);
+      });
+      socket.on('typing_stop', (p: unknown) => {
+        const { roomId, userId } = p as { roomId: string; userId: string };
+        onTypingStop?.(roomId, userId);
+      });
+
+      socket.on('user:status', (p: unknown) => {
+        const { uid, status: s } = p as { uid: string; status: 'online'|'away'|'offline' };
+        onUserStatus?.(uid, s);
+      });
+
+      socket.on('ticket:created',    onTicketCreated   as (...args: unknown[]) => void);
+      socket.on('ticket:updated',    onTicketUpdated   as (...args: unknown[]) => void);
+      socket.on('transfer:assigned', onTransferAssigned as (...args: unknown[]) => void);
+
+      socket.on('error', (p: unknown) => {
+        const { code, message } = p as { code: string; message: string };
+        onError?.(code, message);
+      });
+    }).catch(err => {
+      console.error('[ajaxter-chat] Socket init error:', err.message);
+      if (mountedRef.current) setStatus('error');
+    });
 
-  useEffect(() => {
-    mountedRef.current = true;
-    if (widgetId && viewerUid) connect();
     return () => {
       mountedRef.current = false;
-      if (reconnectTimer.current) clearTimeout(reconnectTimer.current);
-      wsRef.current?.close();
+      socketRef.current?.disconnect();
+      socketRef.current = null;
     };
   // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [widgetId, viewerUid, serverUrl]);
 
+  // ── Public API ────────────────────────────────────────────────────────────
+
   const joinRoom = useCallback((roomId: string) => {
-    currentRoomRef.current = roomId;
-    send('join', { roomId, widgetId });
-  }, [send, widgetId]);
+    currentRoom.current = roomId;
+    emit('join', { roomId, widgetId });
+  }, [emit, widgetId]);
 
   const leaveRoom = useCallback((roomId: string) => {
-    currentRoomRef.current = null;
-    send('leave', { roomId });
-  }, [send]);
+    if (currentRoom.current === roomId) currentRoom.current = null;
+    emit('leave', { roomId });
+  }, [emit]);
 
-  const emitMessage = useCallback((msg: ChatMessage) => {
-    send('message', msg);
-  }, [send]);
+  const emitMessage        = useCallback((msg: ChatMessage) => emit('message', msg), [emit]);
+  const emitTypingStart    = useCallback((roomId: string) => emit('typing_start', { roomId }), [emit]);
+  const emitTypingStop     = useCallback((roomId: string) => emit('typing_stop',  { roomId }), [emit]);
+  const emitMessageRead    = useCallback((roomId: string, messageId: string) => emit('message:read', { roomId, messageId }), [emit]);
 
-  const emitTypingStart = useCallback((roomId: string) => {
-    send('typing_start', { roomId, userId: viewerUid });
-  }, [send, viewerUid]);
+  const emitPauseToggle    = useCallback((roomId: string, targetUserId: string, paused: boolean) =>
+    emit('chat:pause', { roomId, targetUserId, paused }), [emit]);
 
-  const emitTypingStop = useCallback((roomId: string) => {
-    send('typing_stop', { roomId, userId: viewerUid });
-  }, [send, viewerUid]);
+  const emitReport         = useCallback((roomId: string, reason?: string) =>
+    emit('chat:report', { roomId, reason }), [emit]);
 
-  const emitPauseToggle = useCallback((roomId: string, targetUserId: string, paused: boolean) => {
-    send('chat:pause', { roomId, targetUserId, paused });
-  }, [send]);
+  const emitBlock          = useCallback((blockedUid: string) => emit('user:block',   { blockedUid }), [emit]);
+  const emitUnblock        = useCallback((blockedUid: string) => emit('user:unblock', { blockedUid }), [emit]);
 
-  const emitReport = useCallback((roomId: string, reason?: string) => {
-    send('chat:report', { roomId, reporterId: viewerUid, reason });
-  }, [send, viewerUid]);
+  const emitTransfer       = useCallback((fromRoomId: string, toUserId: string, note?: string) =>
+    emit('transfer', { fromRoomId, toUserId, note }), [emit]);
 
-  const emitBlock = useCallback((blockedUid: string) => {
-    send('user:block', { blockedUid });
-  }, [send]);
+  const emitAddParticipant = useCallback((roomId: string, uid: string) =>
+    emit('room:add-participant', { roomId, uid }), [emit]);
 
-  const emitUnblock = useCallback((blockedUid: string) => {
-    send('user:unblock', { blockedUid });
-  }, [send]);
+  const emitCallOffer      = useCallback((offer: RTCSessionDescriptionInit, toUid: string, callId: string, hasVideo?: boolean) =>
+    emit('call-offer', { offer, to: toUid, callId, hasVideo }), [emit]);
 
-  const emitTransfer = useCallback((fromRoomId: string, toUserId: string, note?: string) => {
-    send('transfer', { fromRoomId, toUserId, note });
-  }, [send]);
+  const emitCallAnswer     = useCallback((answer: RTCSessionDescriptionInit, toUid: string, callId: string) =>
+    emit('call-answer', { answer, to: toUid, callId }), [emit]);
 
-  const emitCallOffer = useCallback((offer: RTCSessionDescriptionInit, toUid: string, callId: string) => {
-    send('call-offer', { offer, to: toUid, from: viewerUid, callId });
-  }, [send, viewerUid]);
+  const emitIceCandidate   = useCallback((candidate: RTCIceCandidateInit, toUid: string) =>
+    emit('ice-candidate', { candidate, to: toUid }), [emit]);
 
-  const emitCallAnswer = useCallback((answer: RTCSessionDescriptionInit, toUid: string, callId: string) => {
-    send('call-answer', { answer, to: toUid, callId });
-  }, [send]);
+  const emitCallEnd        = useCallback((callId: string, toUid?: string) =>
+    emit('call-end', { callId, to: toUid }), [emit]);
 
-  const emitIceCandidate = useCallback((candidate: RTCIceCandidateInit, toUid: string) => {
-    send('ice-candidate', { candidate, to: toUid });
-  }, [send]);
+  const emitPresence       = useCallback((presenceStatus: 'ACTIVE'|'AWAY'|'DND') =>
+    emit('presence:update', { status: presenceStatus }), [emit]);
 
-  const emitCallEnd = useCallback((callId: string, toUid?: string) => {
-    send('call-end', { callId, to: toUid });
-  }, [send]);
+  const emitTicketCreate   = useCallback((payload: { title: string; description: string; priority: string; createdBy?: string }) =>
+    emit('ticket:create', payload), [emit]);
 
-  const emitAddParticipant = useCallback((roomId: string, uid: string) => {
-    send('room:add-participant', { roomId, uid });
-  }, [send]);
+  const emitTicketUpdate   = useCallback((payload: { ticketId: string; status?: string; priority?: string; assignedTo?: string }) =>
+    emit('ticket:update', payload), [emit]);
 
   return {
     status,
     joinRoom, leaveRoom,
-    emitMessage, emitTypingStart, emitTypingStop,
+    emitMessage, emitTypingStart, emitTypingStop, emitMessageRead,
     emitPauseToggle, emitReport, emitBlock, emitUnblock, emitTransfer,
-    emitCallOffer, emitCallAnswer, emitIceCandidate, emitCallEnd,
     emitAddParticipant,
+    emitCallOffer, emitCallAnswer, emitIceCandidate, emitCallEnd,
+    emitPresence,
+    emitTicketCreate, emitTicketUpdate,
   };
 }

package/src/index.ts

@@ -27,13 +27,19 @@ export type { PresenceSyncPayload } from './utils/presenceStatus';
 export { avatarColor, initials, formatTime, formatDate, generateTranscript, downloadText, truncateWords } from './utils/chat';
 
 export type {
+  // Core widget
   ChatWidgetProps, ChatWidgetTheme, ChatWidgetViewer,
+  // Config shapes
   WidgetConfig, RemoteChatData,
+  AjaxterConfigResponse, AjaxterInternalConfig, AjaxterWidgetSettings,
+  AjaxterWidgetTheme, AjaxterWidgetFeatures, AjaxterMinimized,
+  // Data models
   ChatUser, ChatMessage, Ticket, RecentChat,
   CallSession, CallState,
-  ChatStatus, ChatType, UserType, OnlineStatus,
-  Screen, BottomTab, UserListContext, MessageType,
-  LocalEnvConfig, PresenceStatus,
+  // Enums / literals
+  ChatStatus, ChatType, DisplayMode, UserType, OnlineStatus,
+  Screen, BottomTab, UserListContext, MessageType, PresenceStatus,
+  LocalEnvConfig,
 } from './types';
 
 export type { UseSocketOptions, SocketStatus, SocketMessageAck } from './hooks/useSocket';