@cstar.help/react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,494 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  CStarChatContext: () => CStarChatContext,
+  CStarChatProvider: () => CStarChatProvider,
+  CStarLibraryContext: () => CStarLibraryContext,
+  CStarLibraryProvider: () => CStarLibraryProvider,
+  useArticle: () => useArticle,
+  useArticleSearch: () => useArticleSearch,
+  useArticles: () => useArticles,
+  useCategories: () => useCategories,
+  useChat: () => useChat,
+  useChatClient: () => useChatClient,
+  useConversations: () => useConversations,
+  useLibraryClient: () => useLibraryClient,
+  useMessages: () => useMessages,
+  useTyping: () => useTyping
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/context.tsx
+var import_react = require("react");
+var CStarChatContext = (0, import_react.createContext)(null);
+var CStarLibraryContext = (0, import_react.createContext)(null);
+function useChatClient() {
+  const client = (0, import_react.useContext)(CStarChatContext);
+  if (!client) {
+    throw new Error("useChatClient must be used within a <CStarChatProvider>");
+  }
+  return client;
+}
+function useLibraryClient() {
+  const client = (0, import_react.useContext)(CStarLibraryContext);
+  if (!client) {
+    throw new Error("useLibraryClient must be used within a <CStarLibraryProvider>");
+  }
+  return client;
+}
+
+// src/chat/CStarChatProvider.tsx
+var import_react2 = require("react");
+var import_chat = require("@cstar.help/js/chat");
+var import_jsx_runtime = require("react/jsx-runtime");
+function CStarChatProvider({ children, ...config }) {
+  const clientRef = (0, import_react2.useRef)(null);
+  if (!clientRef.current) {
+    clientRef.current = new import_chat.ChatClient(config);
+  }
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      clientRef.current?.disconnect();
+      clientRef.current = null;
+    };
+  }, []);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(CStarChatContext.Provider, { value: clientRef.current, children });
+}
+
+// src/chat/useChat.ts
+var import_react3 = require("react");
+function useChat() {
+  const client = useChatClient();
+  const [isIdentified, setIsIdentified] = (0, import_react3.useState)(false);
+  const [isRealtimeReady, setIsRealtimeReady] = (0, import_react3.useState)(false);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const identify = (0, import_react3.useCallback)(
+    async (customer, signature) => {
+      setError(null);
+      try {
+        const result = await client.identify(customer, signature);
+        setIsIdentified(true);
+        client.waitForRealtime().then(() => {
+          setIsRealtimeReady(true);
+        }).catch(() => {
+        });
+        return result;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      }
+    },
+    [client]
+  );
+  const disconnect = (0, import_react3.useCallback)(() => {
+    client.disconnect();
+    setIsIdentified(false);
+    setIsRealtimeReady(false);
+    setError(null);
+  }, [client]);
+  return { identify, disconnect, isIdentified, isRealtimeReady, error };
+}
+
+// src/chat/useConversations.ts
+var import_react4 = require("react");
+function useConversations() {
+  const client = useChatClient();
+  const [conversations, setConversations] = (0, import_react4.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react4.useState)(true);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [hasMore, setHasMore] = (0, import_react4.useState)(false);
+  const mountedRef = (0, import_react4.useRef)(true);
+  const refresh = (0, import_react4.useCallback)(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await client.conversations.list();
+      if (mountedRef.current) {
+        setConversations(result.conversations);
+        setHasMore(result.hasMore);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [client]);
+  (0, import_react4.useEffect)(() => {
+    mountedRef.current = true;
+    refresh();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [refresh]);
+  const create = (0, import_react4.useCallback)(
+    async (params) => {
+      const conversation = await client.conversations.create(params);
+      if (mountedRef.current) {
+        setConversations((prev) => [conversation, ...prev]);
+      }
+      return conversation;
+    },
+    [client]
+  );
+  return { conversations, isLoading, error, hasMore, refresh, create };
+}
+
+// src/chat/useMessages.ts
+var import_react5 = require("react");
+function useMessages(ticketId) {
+  const client = useChatClient();
+  const [messages, setMessages] = (0, import_react5.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react5.useState)(true);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const mountedRef = (0, import_react5.useRef)(true);
+  const seenIdsRef = (0, import_react5.useRef)(/* @__PURE__ */ new Set());
+  const refresh = (0, import_react5.useCallback)(async () => {
+    if (!ticketId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const msgs = await client.messages.list(ticketId);
+      if (mountedRef.current) {
+        seenIdsRef.current = new Set(msgs.map((m) => m.id));
+        setMessages(msgs);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [client, ticketId]);
+  (0, import_react5.useEffect)(() => {
+    mountedRef.current = true;
+    if (!ticketId) {
+      setMessages([]);
+      setIsLoading(false);
+      return;
+    }
+    refresh();
+    const unsubscribe = client.onMessage(ticketId, (msg) => {
+      if (mountedRef.current && !seenIdsRef.current.has(msg.id)) {
+        seenIdsRef.current.add(msg.id);
+        setMessages((prev) => {
+          const optimisticIdx = prev.findIndex(
+            (m) => m.id.startsWith("optimistic-") && m.content === msg.content
+          );
+          if (optimisticIdx >= 0) {
+            const next = [...prev];
+            next[optimisticIdx] = msg;
+            return next;
+          }
+          return [...prev, msg];
+        });
+      }
+    });
+    return () => {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, [client, ticketId, refresh]);
+  const send = (0, import_react5.useCallback)(
+    async (content) => {
+      if (!ticketId) throw new Error("No conversation selected");
+      const optimistic = {
+        id: `optimistic-${Date.now()}`,
+        content,
+        sender: "customer",
+        sender_name: "",
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        read_at: null,
+        attachments: []
+      };
+      setMessages((prev) => [...prev, optimistic]);
+      try {
+        const msg = await client.messages.send(ticketId, content);
+        seenIdsRef.current.add(msg.id);
+        setMessages(
+          (prev) => prev.map((m) => m.id === optimistic.id ? msg : m)
+        );
+        return msg;
+      } catch (err) {
+        setMessages((prev) => prev.filter((m) => m.id !== optimistic.id));
+        throw err;
+      }
+    },
+    [client, ticketId]
+  );
+  return { messages, isLoading, error, send, refresh };
+}
+
+// src/chat/useTyping.ts
+var import_react6 = require("react");
+var TYPING_TIMEOUT = 4e3;
+function useTyping(ticketId) {
+  const client = useChatClient();
+  const [typingAgents, setTypingAgents] = (0, import_react6.useState)([]);
+  const timersRef = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
+  const mountedRef = (0, import_react6.useRef)(true);
+  (0, import_react6.useEffect)(() => {
+    mountedRef.current = true;
+    if (!ticketId) {
+      setTypingAgents([]);
+      return;
+    }
+    const unsubscribe = client.onTyping(ticketId, (payload) => {
+      if (!mountedRef.current) return;
+      const { agent_id, agent_name, is_typing } = payload;
+      const existing = timersRef.current.get(agent_id);
+      if (existing) clearTimeout(existing);
+      if (is_typing) {
+        setTypingAgents((prev) => {
+          if (prev.some((a) => a.agentId === agent_id)) return prev;
+          return [...prev, { agentId: agent_id, agentName: agent_name }];
+        });
+        const timer = setTimeout(() => {
+          if (mountedRef.current) {
+            setTypingAgents((prev) => prev.filter((a) => a.agentId !== agent_id));
+            timersRef.current.delete(agent_id);
+          }
+        }, TYPING_TIMEOUT);
+        timersRef.current.set(agent_id, timer);
+      } else {
+        setTypingAgents((prev) => prev.filter((a) => a.agentId !== agent_id));
+        timersRef.current.delete(agent_id);
+      }
+    });
+    return () => {
+      mountedRef.current = false;
+      unsubscribe();
+      for (const timer of timersRef.current.values()) {
+        clearTimeout(timer);
+      }
+      timersRef.current.clear();
+    };
+  }, [client, ticketId]);
+  const sendTyping = (0, import_react6.useCallback)(
+    async (isTyping) => {
+      if (!ticketId) return;
+      await client.sendTyping(ticketId, isTyping);
+    },
+    [client, ticketId]
+  );
+  return { typingAgents, sendTyping };
+}
+
+// src/library/CStarLibraryProvider.tsx
+var import_react7 = require("react");
+var import_library = require("@cstar.help/js/library");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function CStarLibraryProvider({ children, ...config }) {
+  const clientRef = (0, import_react7.useRef)(null);
+  if (!clientRef.current) {
+    clientRef.current = new import_library.LibraryClient(config);
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CStarLibraryContext.Provider, { value: clientRef.current, children });
+}
+
+// src/library/useCategories.ts
+var import_react8 = require("react");
+function useCategories() {
+  const client = useLibraryClient();
+  const [categories, setCategories] = (0, import_react8.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(true);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const mountedRef = (0, import_react8.useRef)(true);
+  const refresh = (0, import_react8.useCallback)(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await client.categories();
+      if (mountedRef.current) {
+        setCategories(data);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [client]);
+  (0, import_react8.useEffect)(() => {
+    mountedRef.current = true;
+    refresh();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [refresh]);
+  return { categories, isLoading, error, refresh };
+}
+
+// src/library/useArticles.ts
+var import_react9 = require("react");
+function useArticles(params) {
+  const client = useLibraryClient();
+  const [articles, setArticles] = (0, import_react9.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react9.useState)(true);
+  const [error, setError] = (0, import_react9.useState)(null);
+  const mountedRef = (0, import_react9.useRef)(true);
+  const categorySlug = params?.categorySlug;
+  const limit = params?.limit;
+  const offset = params?.offset;
+  const refresh = (0, import_react9.useCallback)(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await client.articles({ categorySlug, limit, offset });
+      if (mountedRef.current) {
+        setArticles(data);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [client, categorySlug, limit, offset]);
+  (0, import_react9.useEffect)(() => {
+    mountedRef.current = true;
+    refresh();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [refresh]);
+  return { articles, isLoading, error, refresh };
+}
+
+// src/library/useArticle.ts
+var import_react10 = require("react");
+function useArticle(slug) {
+  const client = useLibraryClient();
+  const [article, setArticle] = (0, import_react10.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react10.useState)(true);
+  const [error, setError] = (0, import_react10.useState)(null);
+  const mountedRef = (0, import_react10.useRef)(true);
+  const refresh = (0, import_react10.useCallback)(async () => {
+    if (!slug) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const data = await client.article(slug);
+      if (mountedRef.current) {
+        setArticle(data);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setIsLoading(false);
+      }
+    }
+  }, [client, slug]);
+  (0, import_react10.useEffect)(() => {
+    mountedRef.current = true;
+    if (!slug) {
+      setArticle(null);
+      setIsLoading(false);
+      return;
+    }
+    refresh();
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [slug, refresh]);
+  return { article, isLoading, error, refresh };
+}
+
+// src/library/useArticleSearch.ts
+var import_react11 = require("react");
+var DEBOUNCE_MS = 300;
+function useArticleSearch(query) {
+  const client = useLibraryClient();
+  const [results, setResults] = (0, import_react11.useState)([]);
+  const [totalCount, setTotalCount] = (0, import_react11.useState)(0);
+  const [isLoading, setIsLoading] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const mountedRef = (0, import_react11.useRef)(true);
+  (0, import_react11.useEffect)(() => {
+    mountedRef.current = true;
+    const trimmed = query.trim();
+    if (!trimmed) {
+      setResults([]);
+      setTotalCount(0);
+      setIsLoading(false);
+      setError(null);
+      return;
+    }
+    setIsLoading(true);
+    const timer = setTimeout(async () => {
+      try {
+        const result = await client.search(trimmed);
+        if (mountedRef.current) {
+          setResults(result.data);
+          setTotalCount(result.count);
+          setError(null);
+        }
+      } catch (err) {
+        if (mountedRef.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (mountedRef.current) {
+          setIsLoading(false);
+        }
+      }
+    }, DEBOUNCE_MS);
+    return () => {
+      mountedRef.current = false;
+      clearTimeout(timer);
+    };
+  }, [client, query]);
+  return { results, totalCount, isLoading, error };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CStarChatContext,
+  CStarChatProvider,
+  CStarLibraryContext,
+  CStarLibraryProvider,
+  useArticle,
+  useArticleSearch,
+  useArticles,
+  useCategories,
+  useChat,
+  useChatClient,
+  useConversations,
+  useLibraryClient,
+  useMessages,
+  useTyping
+});

package/dist/index.d.cts

@@ -0,0 +1,218 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { ChatClient, ChatConfig, IdentifyParams, IdentifyResult, Conversation, ConversationCreateParams, WidgetMessage } from '@cstar.help/js/chat';
+export { ChatConfig, Conversation, ConversationCreateParams, ConversationListResponse, IdentifyParams, IdentifyResult, TypingPayload, WidgetMessage } from '@cstar.help/js/chat';
+import { LibraryClient, LibraryConfig, Category, LibraryArticle, LibraryArticleListParams } from '@cstar.help/js/library';
+export { Category, LibraryArticle, LibraryArticleListParams, LibraryConfig, LibrarySearchParams, LibrarySearchResult } from '@cstar.help/js/library';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare const CStarChatContext: react.Context<ChatClient | null>;
+declare const CStarLibraryContext: react.Context<LibraryClient | null>;
+/**
+ * Access the ChatClient from the nearest CStarChatProvider.
+ * Throws if used outside a provider.
+ */
+declare function useChatClient(): ChatClient;
+/**
+ * Access the LibraryClient from the nearest CStarLibraryProvider.
+ * Throws if used outside a provider.
+ */
+declare function useLibraryClient(): LibraryClient;
+
+interface CStarChatProviderProps extends ChatConfig {
+    children: ReactNode;
+}
+/**
+ * Provides a ChatClient instance to all child components.
+ * Creates the client on mount and disconnects on unmount.
+ *
+ * ```tsx
+ * <CStarChatProvider teamSlug="acme" supabaseUrl="..." supabaseAnonKey="...">
+ *   <ChatWidget />
+ * </CStarChatProvider>
+ * ```
+ */
+declare function CStarChatProvider({ children, ...config }: CStarChatProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UseChatReturn {
+    /** Identify a customer with HMAC signature. */
+    identify: (customer: IdentifyParams, signature: string) => Promise<IdentifyResult>;
+    /** Disconnect the client and clean up all subscriptions. */
+    disconnect: () => void;
+    /** Whether a customer has been successfully identified. */
+    isIdentified: boolean;
+    /** Whether the Supabase Realtime connection is ready. */
+    isRealtimeReady: boolean;
+    /** The last error from identify, or null. */
+    error: Error | null;
+}
+/**
+ * Core chat hook — manages identity verification and realtime readiness.
+ *
+ * ```tsx
+ * const { identify, disconnect, isIdentified, isRealtimeReady, error } = useChat();
+ *
+ * await identify(
+ *   { externalId: 'usr_123', email: 'jane@co.com', timestamp: Date.now() / 1000 },
+ *   hmacSignature
+ * );
+ * ```
+ */
+declare function useChat(): UseChatReturn;
+
+interface UseConversationsReturn {
+    /** List of conversations for the identified customer. */
+    conversations: Conversation[];
+    /** Whether the initial fetch is in progress. */
+    isLoading: boolean;
+    /** The last error, or null. */
+    error: Error | null;
+    /** Whether there are more conversations to load. */
+    hasMore: boolean;
+    /** Re-fetch the conversation list. */
+    refresh: () => Promise<void>;
+    /** Create a new conversation. */
+    create: (params: ConversationCreateParams) => Promise<Conversation>;
+}
+/**
+ * Manage the customer's conversation list.
+ *
+ * ```tsx
+ * const { conversations, isLoading, create, refresh } = useConversations();
+ * ```
+ */
+declare function useConversations(): UseConversationsReturn;
+
+interface UseMessagesReturn {
+    /** Messages in the conversation, oldest first. */
+    messages: WidgetMessage[];
+    /** Whether the initial fetch is in progress. */
+    isLoading: boolean;
+    /** The last error, or null. */
+    error: Error | null;
+    /** Send a message. Optimistically appended, replaced with server response. */
+    send: (content: string) => Promise<WidgetMessage>;
+    /** Re-fetch messages from the API. */
+    refresh: () => Promise<void>;
+}
+/**
+ * Manage messages for a single conversation with automatic real-time updates.
+ *
+ * ```tsx
+ * const { messages, isLoading, send } = useMessages(ticketId);
+ * await send('Hello!');
+ * ```
+ */
+declare function useMessages(ticketId: string | null): UseMessagesReturn;
+
+interface TypingAgent {
+    agentId: string;
+    agentName: string;
+}
+interface UseTypingReturn {
+    /** Agents currently typing. Auto-cleared after 4s of no activity. */
+    typingAgents: TypingAgent[];
+    /** Send a customer typing indicator. */
+    sendTyping: (isTyping: boolean) => Promise<void>;
+}
+/**
+ * Track agent typing indicators for a conversation.
+ *
+ * ```tsx
+ * const { typingAgents, sendTyping } = useTyping(ticketId);
+ * ```
+ */
+declare function useTyping(ticketId: string | null): UseTypingReturn;
+
+interface CStarLibraryProviderProps extends LibraryConfig {
+    children: ReactNode;
+}
+/**
+ * Provides a LibraryClient instance to all child components.
+ *
+ * ```tsx
+ * <CStarLibraryProvider teamSlug="acme">
+ *   <KnowledgeBase />
+ * </CStarLibraryProvider>
+ * ```
+ */
+declare function CStarLibraryProvider({ children, ...config }: CStarLibraryProviderProps): react_jsx_runtime.JSX.Element;
+
+interface UseCategoriesReturn {
+    /** All public categories. */
+    categories: Category[];
+    /** Whether the initial fetch is in progress. */
+    isLoading: boolean;
+    /** The last error, or null. */
+    error: Error | null;
+    /** Re-fetch categories. */
+    refresh: () => Promise<void>;
+}
+/**
+ * Fetch public knowledge base categories.
+ *
+ * ```tsx
+ * const { categories, isLoading, error } = useCategories();
+ * ```
+ */
+declare function useCategories(): UseCategoriesReturn;
+
+interface UseArticlesReturn {
+    /** Published articles. */
+    articles: LibraryArticle[];
+    /** Whether the fetch is in progress. */
+    isLoading: boolean;
+    /** The last error, or null. */
+    error: Error | null;
+    /** Re-fetch articles with the current params. */
+    refresh: () => Promise<void>;
+}
+/**
+ * Fetch published articles, optionally filtered by category.
+ *
+ * ```tsx
+ * const { articles, isLoading } = useArticles({ categorySlug: 'getting-started' });
+ * ```
+ */
+declare function useArticles(params?: LibraryArticleListParams): UseArticlesReturn;
+
+interface UseArticleReturn {
+    /** The article, or null if not yet loaded. */
+    article: LibraryArticle | null;
+    /** Whether the fetch is in progress. */
+    isLoading: boolean;
+    /** The last error, or null. */
+    error: Error | null;
+    /** Re-fetch the article. */
+    refresh: () => Promise<void>;
+}
+/**
+ * Fetch a single article by slug.
+ *
+ * ```tsx
+ * const { article, isLoading, error } = useArticle('getting-started');
+ * ```
+ */
+declare function useArticle(slug: string | null): UseArticleReturn;
+
+interface UseArticleSearchReturn {
+    /** Search results. */
+    results: LibraryArticle[];
+    /** Total number of matching articles. */
+    totalCount: number;
+    /** Whether a search is in progress. */
+    isLoading: boolean;
+    /** The last error, or null. */
+    error: Error | null;
+}
+/**
+ * Search articles with automatic debouncing (300ms).
+ * Clears results when query is empty.
+ *
+ * ```tsx
+ * const { results, totalCount, isLoading } = useArticleSearch(searchTerm);
+ * ```
+ */
+declare function useArticleSearch(query: string): UseArticleSearchReturn;
+
+export { CStarChatContext, CStarChatProvider, type CStarChatProviderProps, CStarLibraryContext, CStarLibraryProvider, type CStarLibraryProviderProps, type TypingAgent, type UseArticleReturn, type UseArticleSearchReturn, type UseArticlesReturn, type UseCategoriesReturn, type UseChatReturn, type UseConversationsReturn, type UseMessagesReturn, type UseTypingReturn, useArticle, useArticleSearch, useArticles, useCategories, useChat, useChatClient, useConversations, useLibraryClient, useMessages, useTyping };