@cossistant/next 0.0.1

package/typing-indicator.d.ts

@@ -0,0 +1,24 @@
+import * as React$1 from "react";
+import "react/jsx-runtime";
+
+//#region ../react/src/support/components/typing-indicator.d.ts
+type TypingParticipantType = "visitor" | "team_member" | "ai";
+type TypingParticipant = {
+  id: string;
+  type: TypingParticipantType;
+};
+type TypingIndicatorProps = React$1.HTMLAttributes<HTMLDivElement> & {
+  participants: TypingParticipant[];
+  availableAIAgents?: AvailableAIAgent[];
+  availableHumanAgents?: AvailableHumanAgent[];
+  withAvatars?: boolean;
+};
+declare const TypingIndicator: React$1.ForwardRefExoticComponent<React$1.HTMLAttributes<HTMLDivElement> & {
+  participants: TypingParticipant[];
+  availableAIAgents?: AvailableAIAgent[];
+  availableHumanAgents?: AvailableHumanAgent[];
+  withAvatars?: boolean;
+} & React$1.RefAttributes<HTMLDivElement>>;
+//#endregion
+export { TypingIndicator, TypingIndicatorProps, TypingParticipant, TypingParticipantType };
+//# sourceMappingURL=typing-indicator.d.ts.map

package/typing-indicator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing-indicator.d.ts","names":[],"sources":["../../react/src/support/components/typing-indicator.tsx"],"sourcesContent":[],"mappings":";;;;KAKY,qBAAA;KAEA,iBAAA;EAFA,EAAA,EAAA,MAAA;EAEA,IAAA,EAEL,qBAFsB;AAK7B,CAAA;AAAgC,KAApB,oBAAA,GAAuB,OAAA,CAAM,cAAT,CAAwB,cAAxB,CAAA,GAAA;cAAwB,EACzC,iBADyC,EAAA;mBAAf,CAAA,EAEpB,gBAFoB,EAAA;sBAC1B,CAAA,EAES,mBAFT,EAAA;aACM,CAAA,EAAA,OAAA;;AAaR,cAAA,eAuDZ,EAvD2B,OAAA,CAAA,yBAuD3B,CAvD2B,OAAA,CAAA,cAuD3B,CAvD2B,cAuD3B,CAAA,GAAA;EAAA,YAAA,EArEc,iBAqEd,EAAA;mBAvD2B,CAAA,EAbP,gBAaO,EAAA;sBAAA,CAAA,EAZJ,mBAYI,EAAA;aAdb,CAAA,EAAA,OAAA;yBACM,eAAA,CAAA,CAAA"}

package/typing-store.d.ts

@@ -0,0 +1,25 @@
+//#region ../react/src/realtime/typing-store.d.ts
+
+declare function setTypingState(options: {
+  conversationId: string;
+  actorType: TypingActorType;
+  actorId: string;
+  isTyping: boolean;
+  preview?: string | null;
+  ttlMs?: number;
+}): void;
+declare function clearTypingState(options: {
+  conversationId: string;
+  actorType: TypingActorType;
+  actorId: string;
+}): void;
+declare function applyConversationTypingEvent(event: RealtimeEvent<"conversationTyping">, options?: {
+  ignoreVisitorId?: string | null;
+  ignoreUserId?: string | null;
+  ignoreAiAgentId?: string | null;
+  ttlMs?: number;
+}): void;
+declare function clearTypingFromTimelineItem(event: RealtimeEvent<"timelineItemCreated">): void;
+//#endregion
+export { applyConversationTypingEvent, clearTypingFromTimelineItem, clearTypingState, setTypingState };
+//# sourceMappingURL=typing-store.d.ts.map

package/typing-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typing-store.d.ts","names":[],"sources":["../../react/src/realtime/typing-store.ts"],"sourcesContent":[],"mappings":";;iBAwDgB,cAAA;;aAEJ;;;;;;iBASI,gBAAA;;aAEJ;;;iBAMI,4BAAA,QACR;;;;;;iBAWQ,2BAAA,QACR"}

package/use-client-query.d.ts

@@ -0,0 +1,23 @@
+//#region ../react/src/hooks/private/use-client-query.d.ts
+type QueryFn<TData, TArgs> = (client: CossistantClient, args?: TArgs | undefined) => Promise<TData>;
+type UseClientQueryOptions<TData, TArgs> = {
+  client: CossistantClient;
+  queryFn: QueryFn<TData, TArgs>;
+  enabled?: boolean;
+  refetchInterval?: number | false;
+  refetchOnWindowFocus?: boolean;
+  refetchOnMount?: boolean;
+  initialData?: TData;
+  initialArgs?: TArgs;
+  dependencies?: readonly unknown[];
+};
+type UseClientQueryResult<TData, TArgs> = {
+  data: TData | undefined;
+  error: Error | null;
+  isLoading: boolean;
+  refetch: (args?: TArgs) => Promise<TData | undefined>;
+};
+declare function useClientQuery<TData, TArgs = void>(options: UseClientQueryOptions<TData, TArgs>): UseClientQueryResult<TData, TArgs>;
+//#endregion
+export { useClientQuery };
+//# sourceMappingURL=use-client-query.d.ts.map

package/use-client-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-client-query.d.ts","names":[],"sources":["../../react/src/hooks/private/use-client-query.ts"],"sourcesContent":[],"mappings":";AAAyD,KAGpD,OAAA,CAAA,KAAO,EAAA,KAAA,CAAA,GAAA,CAAA,MAAA,EACH,gBADG,EAAA,IAAA,CAAA,EAEJ,KAFI,GAAA,SAAA,EAAA,GAGP,OAHO,CAGC,KAHD,CAAA;KAKP,qBALO,CAAA,KAAA,EAAA,KAAA,CAAA,GAAA;QACH,EAKA,gBALA;SACD,EAKE,OALF,CAKU,KALV,EAKiB,KALjB,CAAA;SACK,CAAA,EAAA,OAAA;iBAAR,CAAA,EAAA,MAAA,GAAA,KAAA;EAAO,oBAAA,CAAA,EAAA,OAAA;EAEP,cAAA,CAAA,EAAA,OAAqB;EAAA,WAAA,CAAA,EAOX,KAPW;aACjB,CAAA,EAOM,KAPN;cACS,CAAA,EAAA,SAAA,OAAA,EAAA;;KAUb,oBAVK,CAAA,KAAA,EAAA,KAAA,CAAA,GAAA;MAKK,EAMR,KANQ,GAAA,SAAA;OACA,EAMP,KANO,GAAA,IAAA;EAAK,SAAA,EAAA,OAAA;EAIf,OAAA,EAAA,CAAA,IAAA,CAAA,EAIa,KAJb,EAAoB,GAIG,OAJH,CAIW,KAJX,GAAA,SAAA,CAAA;CAAA;AAClB,iBAgBS,cAhBT,CAAA,KAAA,EAAA,QAAA,IAAA,CAAA,CAAA,OAAA,EAiBG,qBAjBH,CAiByB,KAjBzB,EAiBgC,KAjBhC,CAAA,CAAA,EAkBJ,oBAlBI,CAkBiB,KAlBjB,EAkBwB,KAlBxB,CAAA"}

package/use-composer-refocus.d.ts

@@ -0,0 +1,20 @@
+import { MutableRefObject } from "react";
+
+//#region ../react/src/hooks/use-composer-refocus.d.ts
+type UseComposerRefocusOptions = {
+  disabled: boolean;
+  hasContent: boolean;
+  isSubmitting: boolean;
+};
+type UseComposerRefocusReturn = {
+  focusComposer: () => void;
+  inputRef: MutableRefObject<HTMLTextAreaElement | null>;
+};
+declare const useComposerRefocus: ({
+  disabled,
+  hasContent,
+  isSubmitting
+}: UseComposerRefocusOptions) => UseComposerRefocusReturn;
+//#endregion
+export { UseComposerRefocusOptions, UseComposerRefocusReturn, useComposerRefocus };
+//# sourceMappingURL=use-composer-refocus.d.ts.map

package/use-composer-refocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-composer-refocus.d.ts","names":[],"sources":["../../react/src/hooks/use-composer-refocus.ts"],"sourcesContent":[],"mappings":";;;KAGY,yBAAA;;EAAA,UAAA,EAAA,OAAA;EAMA,YAAA,EAAA,OAAA;CAAwB;AAER,KAFhB,wBAAA,GAEgB;eAAjB,EAAA,GAAA,GAAA,IAAA;EAAgB,QAAA,EAAhB,gBAAgB,CAAC,mBAAD,GAAA,IAAA,CAAA;AAG3B,CAAA;AAmCC,cAnCY,kBAmCZ,EAAA,CAAA;EAAA,QAAA;EAAA,UAAA;EAAA;AAAA,CAAA,EA/BE,yBA+BF,EAAA,GA/B8B,wBA+B9B"}

package/use-conversation-auto-seen.d.ts

@@ -0,0 +1,52 @@
+//#region ../react/src/hooks/use-conversation-auto-seen.d.ts
+
+declare const CONVERSATION_AUTO_SEEN_DELAY_MS = 2000;
+type UseConversationAutoSeenOptions = {
+  /**
+   * The Cossistant client instance.
+   */
+  client: CossistantClient | null;
+  /**
+   * The real conversation ID. Pass null if no conversation exists yet.
+   */
+  conversationId: string | null;
+  /**
+   * Current visitor ID.
+   */
+  visitorId?: string;
+  /**
+   * The last timeline item in the conversation.
+   * Used to determine if we should mark as seen.
+   */
+  lastTimelineItem: TimelineItem | null;
+  /**
+   * Whether to enable auto-seen tracking.
+   * Default: true
+   */
+  enabled?: boolean;
+};
+/**
+ * Automatically marks timeline items as seen when:
+ * - A new timeline item arrives from someone else
+ * - The page is visible/focused
+ * - The visitor is the current user
+ *
+ * Also handles:
+ * - Fetching and hydrating initial seen data
+ * - Preventing duplicate API calls
+ * - Page visibility tracking
+ *
+ * @example
+ * ```tsx
+ * useConversationAutoSeen({
+ *   client,
+ *   conversationId: realConversationId,
+ *   visitorId: visitor?.id,
+ *   lastTimelineItem: items[items.length - 1] ?? null,
+ * });
+ * ```
+ */
+declare function useConversationAutoSeen(options: UseConversationAutoSeenOptions): void;
+//#endregion
+export { CONVERSATION_AUTO_SEEN_DELAY_MS, UseConversationAutoSeenOptions, useConversationAutoSeen };
+//# sourceMappingURL=use-conversation-auto-seen.d.ts.map

package/use-conversation-auto-seen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-auto-seen.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-auto-seen.ts"],"sourcesContent":[],"mappings":";;AAWY,cAFC,+BAAA,GAE6B,IAAA;AAAA,KAA9B,8BAAA,GAA8B;;;;EAkD1B,MAAA,EA9CP,gBA8CO,GAAuB,IAAA;;;;;;;;;;;;;oBA9BpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BH,uBAAA,UACN"}

package/use-conversation-history-page.d.ts

@@ -0,0 +1,84 @@
+//#region ../react/src/hooks/use-conversation-history-page.d.ts
+type UseConversationHistoryPageOptions = {
+  /**
+   * Initial number of conversations to display.
+   * Default: 4
+   */
+  initialVisibleCount?: number;
+  /**
+   * Whether to enable conversations fetching.
+   * Default: true
+   */
+  enabled?: boolean;
+  /**
+   * Callback when user wants to open a conversation.
+   */
+  onOpenConversation?: (conversationId: string) => void;
+  /**
+   * Callback when user wants to start a new conversation.
+   */
+  onStartConversation?: (initialMessage?: string) => void;
+};
+type UseConversationHistoryPageReturn = {
+  conversations: Conversation[];
+  isLoading: boolean;
+  error: Error | null;
+  visibleConversations: Conversation[];
+  visibleCount: number;
+  hasMore: boolean;
+  remainingCount: number;
+  showMore: () => void;
+  showAll: () => void;
+  openConversation: (conversationId: string) => void;
+  startConversation: (initialMessage?: string) => void;
+};
+/**
+ * Main hook for the conversation history page.
+ *
+ * This hook:
+ * - Fetches all conversations
+ * - Manages pagination/visible count
+ * - Provides navigation actions
+ *
+ * It encapsulates all conversation history logic, making the component
+ * purely presentational.
+ *
+ * @example
+ * ```tsx
+ * export function ConversationHistoryPage() {
+ *   const history = useConversationHistoryPage({
+ *     initialVisibleCount: 4,
+ *     onOpenConversation: (id) => {
+ *       navigate('conversation', { conversationId: id });
+ *     },
+ *     onStartConversation: (msg) => {
+ *       navigate('conversation', { conversationId: PENDING_CONVERSATION_ID, initialMessage: msg });
+ *     },
+ *   });
+ *
+ *   return (
+ *     <>
+ *       <h1>Conversation History</h1>
+ *
+ *       {history.hasMore && (
+ *         <button onClick={history.showAll}>
+ *           +{history.remainingCount} more
+ *         </button>
+ *       )}
+ *
+ *       <ul>
+ *         {history.visibleConversations.map(conv => (
+ *           <li key={conv.id} onClick={() => history.openConversation(conv.id)}>
+ *             {conv.title}
+ *           </li>
+ *         ))}
+ *       </ul>
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useConversationHistoryPage(options?: UseConversationHistoryPageOptions): UseConversationHistoryPageReturn;
+//#endregion
+export { UseConversationHistoryPageOptions, UseConversationHistoryPageReturn, useConversationHistoryPage };
+//# sourceMappingURL=use-conversation-history-page.d.ts.map

package/use-conversation-history-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-history-page.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-history-page.ts"],"sourcesContent":[],"mappings":";AAIY,KAAA,iCAAA,GAAiC;EAwBjC;;;;qBAOW,CAAA,EAAA,MAAA;EAAY;AA0DnC;;;SAEG,CAAA,EAAA,OAAA;EAAgC;;;;;;;;;KAnEvB,gCAAA;iBAEI;;SAER;wBAGe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0DP,0BAAA,WACN,oCACP"}

package/use-conversation-lifecycle.d.ts

@@ -0,0 +1,80 @@
+//#region ../react/src/hooks/use-conversation-lifecycle.d.ts
+type ConversationLifecycleState = {
+  /**
+   * The current conversation ID. Always a string, never null.
+   * Will be PENDING_CONVERSATION_ID if no real conversation exists yet.
+   */
+  conversationId: string;
+  /**
+   * Whether this is a pending (not yet created) conversation.
+   * True = showing default messages, no backend conversation yet.
+   * False = real conversation exists on backend.
+   */
+  isPending: boolean;
+  /**
+   * The real conversation ID if one exists, otherwise null.
+   * Use this when you need to pass to API calls that require an existing conversation.
+   */
+  realConversationId: string | null;
+};
+type UseConversationLifecycleOptions = {
+  /**
+   * Initial conversation ID from URL or navigation state.
+   * Can be PENDING_CONVERSATION_ID or a real conversation ID.
+   */
+  initialConversationId?: string;
+  /**
+   * Whether to automatically create a conversation on mount.
+   * If false, conversation will only be created when user sends first message.
+   * Default: false (lazy creation)
+   */
+  autoCreate?: boolean;
+  /**
+   * Visitor ID to associate with the conversation.
+   */
+  visitorId?: string;
+  /**
+   * Website ID to associate with the conversation.
+   */
+  websiteId?: string | null;
+  /**
+   * Callback when conversation is created.
+   */
+  onConversationCreated?: (conversationId: string) => void;
+};
+type UseConversationLifecycleReturn = ConversationLifecycleState & {
+  /**
+   * Update the conversation ID (e.g., after creation or navigation).
+   */
+  setConversationId: (conversationId: string) => void;
+  /**
+   * Check if this is a new/pending conversation.
+   */
+  isNewConversation: () => boolean;
+};
+/**
+ * Manages the lifecycle of a conversation, handling the transition from
+ * a pending state (showing default messages) to a real conversation
+ * (with backend persistence).
+ *
+ * This hook simplifies the logic of:
+ * - Starting with default/welcome messages
+ * - Creating the conversation only when user sends first message
+ * - Transitioning from pending → real conversation ID
+ *
+ * @example
+ * ```tsx
+ * const { conversationId, isPending, realConversationId } = useConversationLifecycle({
+ *   initialConversationId: params.conversationId,
+ *   visitorId: visitor?.id,
+ * });
+ *
+ * // conversationId is always a string (never null)
+ * // isPending tells you if it's a real conversation or not
+ * // realConversationId is null when isPending=true, otherwise it's the real ID
+ * ```
+ */
+declare function useConversationLifecycle(options?: UseConversationLifecycleOptions): UseConversationLifecycleReturn;
+//#endregion
+export { ConversationLifecycleState, UseConversationLifecycleOptions, UseConversationLifecycleReturn, useConversationLifecycle };
+//# sourceMappingURL=use-conversation-lifecycle.d.ts.map

package/use-conversation-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-lifecycle.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-lifecycle.ts"],"sourcesContent":[],"mappings":";KAGY,0BAAA;EAAA;AAqBZ;AA8BA;AAkCA;EAAwC,cAAA,EAAA,MAAA;;;;;;;;;;;;;KAhE5B,+BAAA;;;;;;;;;;;;;;;;;;;;;;;;;KA8BA,8BAAA,GAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkC7B,wBAAA,WACN,kCACP"}

package/use-conversation-page.d.ts

@@ -0,0 +1,80 @@
+//#region ../react/src/hooks/use-conversation-page.d.ts
+type UseConversationPageOptions = {
+  /**
+   * Initial conversation ID (from URL params, navigation state, etc.)
+   * Can be PENDING_CONVERSATION_ID or a real ID.
+   */
+  conversationId: string;
+  /**
+   * Optional initial message to send when the conversation opens.
+   */
+  initialMessage?: string;
+  /**
+   * Callback when conversation ID changes (e.g., after creation).
+   * Use this to update navigation state or URL.
+   */
+  onConversationIdChange?: (conversationId: string) => void;
+  /**
+   * Optional timeline items to pass through (e.g., optimistic updates).
+   */
+  items?: TimelineItem[];
+};
+type UseConversationPageReturn = {
+  conversationId: string;
+  isPending: boolean;
+  items: TimelineItem[];
+  isLoading: boolean;
+  error: Error | null;
+  composer: {
+    message: string;
+    files: File[];
+    isSubmitting: boolean;
+    canSubmit: boolean;
+    setMessage: (message: string) => void;
+    addFiles: (files: File[]) => void;
+    removeFile: (index: number) => void;
+    submit: () => void;
+  };
+  hasItems: boolean;
+  lastTimelineItem: TimelineItem | null;
+};
+/**
+ * Main orchestrator hook for the conversation page.
+ *
+ * This hook combines all conversation-related logic:
+ * - Lifecycle management (pending → real conversation)
+ * - Message fetching and display
+ * - Message composition and sending
+ * - Automatic seen tracking
+ * - Default/welcome messages before conversation is created
+ *
+ * It provides a clean, simple API for building conversation UIs.
+ *
+ * @example
+ * ```tsx
+ * export function ConversationPage({ conversationId: initialId }) {
+ *   const conversation = useConversationPage({
+ *     conversationId: initialId,
+ *     onConversationIdChange: (newId) => {
+ *       // Update URL or navigation state
+ *       navigate(`/conversation/${newId}`);
+ *     },
+ *   });
+ *
+ *   return (
+ *     <>
+ *       <MessageList messages={conversation.messages} />
+ *       <MessageInput
+ *         value={conversation.composer.message}
+ *         onChange={conversation.composer.setMessage}
+ *         onSubmit={conversation.composer.submit}
+ *       />
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+declare function useConversationPage(options: UseConversationPageOptions): UseConversationPageReturn;
+//#endregion
+export { UseConversationPageOptions, UseConversationPageReturn, useConversationPage };
+//# sourceMappingURL=use-conversation-page.d.ts.map

package/use-conversation-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-page.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-page.ts"],"sourcesContent":[],"mappings":";AASY,KAAA,0BAAA,GAA0B;EAwB1B;;;;gBAWH,EAAA,MAAA;;;;EAkDO,cAAA,CAAA,EAAA,MAAmB;EAAA;;;;;;;;UAhE1B;;KAGG,yBAAA;;;SAIJ;;SAEA;;;WAKC;;;;sBAIW;;;;;oBAOD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCH,mBAAA,UACN,6BACP"}

package/use-conversation-seen.d.ts

@@ -0,0 +1,15 @@
+//#region ../react/src/hooks/use-conversation-seen.d.ts
+type UseConversationSeenOptions = {
+  initialData?: ConversationSeen[];
+};
+declare function useConversationSeen(conversationId: string | null | undefined, options?: UseConversationSeenOptions): ConversationSeen[];
+/**
+ * Debounced version of useConversationSeen that delays updates by 500ms
+ * to prevent animation conflicts when messages are sent and immediately seen.
+ *
+ * Use this in UI components where smooth animations are critical.
+ */
+declare function useDebouncedConversationSeen(conversationId: string | null | undefined, options?: UseConversationSeenOptions, delay?: number): ConversationSeen[];
+//#endregion
+export { useConversationSeen, useDebouncedConversationSeen };
+//# sourceMappingURL=use-conversation-seen.d.ts.map

package/use-conversation-seen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-seen.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-seen.ts"],"sourcesContent":[],"mappings":";AAAkE,KAI7D,0BAAA,GAA0B;EAYf,WAAA,CAAA,EAXD,gBAWoB,EAAA;CAAA;AAEzB,iBAFM,mBAAA,CAEN,cAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA,EAAA,OAAA,CAAA,EAAA,0BAAA,CAAA,EACP,gBADO,EAAA;;;AAsDV;;;;AAImB,iBAJH,4BAAA,CAIG,cAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA,EAAA,OAAA,CAAA,EAFT,0BAES,EAAA,KAAA,CAAA,EAAA,MAAA,CAAA,EAAhB,gBAAgB,EAAA"}

package/use-conversation-timeline-items.d.ts

@@ -0,0 +1,19 @@
+//#region ../react/src/hooks/use-conversation-timeline-items.d.ts
+
+type UseConversationTimelineItemsOptions = {
+  limit?: number;
+  cursor?: string | null;
+  enabled?: boolean;
+  refetchInterval?: number | false;
+  refetchOnWindowFocus?: boolean;
+};
+type UseConversationTimelineItemsResult = ConversationTimelineItemsState & {
+  isLoading: boolean;
+  error: Error | null;
+  refetch: (args?: Pick<GetConversationTimelineItemsRequest, "cursor" | "limit">) => Promise<GetConversationTimelineItemsResponse | undefined>;
+  fetchNextPage: () => Promise<GetConversationTimelineItemsResponse | undefined>;
+};
+declare function useConversationTimelineItems(conversationId: string | null | undefined, options?: UseConversationTimelineItemsOptions): UseConversationTimelineItemsResult;
+//#endregion
+export { UseConversationTimelineItemsOptions, UseConversationTimelineItemsResult, useConversationTimelineItems };
+//# sourceMappingURL=use-conversation-timeline-items.d.ts.map

package/use-conversation-timeline-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-timeline-items.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-timeline-items.ts"],"sourcesContent":[],"mappings":";;AA4BY,KARA,mCAAA,GAQkC;EAAA,KAAA,CAAA,EAAA,MAAA;QAC7C,CAAA,EAAA,MAAA,GAAA,IAAA;SAEQ,CAAA,EAAA,OAAA;iBAEM,CAAA,EAAA,MAAA,GAAA,KAAA;sBAAL,CAAA,EAAA,OAAA;;AACH,KANK,kCAAA,GACX,8BAKM,GAAA;WAEJ,EAAA,OAAA;OADoB,EAJd,KAIc,GAAA,IAAA;EAAO,OAAA,EAAA,CAAA,IAAA,CAAA,EAFpB,IAEoB,CAFf,mCAEe,EAAA,QAAA,GAAA,OAAA,CAAA,EAAA,GADvB,OACuB,CADf,oCACe,GAAA,SAAA,CAAA;EAKd,aAAA,EAAA,GAAA,GALO,OAKP,CAJb,oCAIyC,GAAA,SAAA,CAAA;CAAA;AAElC,iBAFM,4BAAA,CAEN,cAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA,EAAA,OAAA,CAAA,EAAA,mCAAA,CAAA,EACP,kCADO"}

package/use-conversation-typing.d.ts

@@ -0,0 +1,11 @@
+//#region ../react/src/hooks/use-conversation-typing.d.ts
+type ConversationTypingParticipant = TypingEntry;
+type UseConversationTypingOptions = {
+  excludeVisitorId?: string | null;
+  excludeUserId?: string | null;
+  excludeAiAgentId?: string | null;
+};
+declare function useConversationTyping(conversationId: string | null | undefined, options?: UseConversationTypingOptions): ConversationTypingParticipant[];
+//#endregion
+export { ConversationTypingParticipant, useConversationTyping };
+//# sourceMappingURL=use-conversation-typing.d.ts.map

package/use-conversation-typing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation-typing.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation-typing.ts"],"sourcesContent":[],"mappings":";AAIY,KAAA,6BAAA,GAAgC,WAAA;AAAY,KAEnD,4BAAA,GAA4B;EAyBjB,gBAAA,CAAA,EAAA,MAAqB,GAAA,IAAA;EAAA,aAAA,CAAA,EAAA,MAAA,GAAA,IAAA;kBAE3B,CAAA,EAAA,MAAA,GAAA,IAAA;;AACsB,iBAHhB,qBAAA,CAGgB,cAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA,EAAA,OAAA,CAAA,EADtB,4BACsB,CAAA,EAA7B,6BAA6B,EAAA"}

package/use-conversation.d.ts

@@ -0,0 +1,16 @@
+//#region ../react/src/hooks/use-conversation.d.ts
+type UseConversationOptions = {
+  enabled?: boolean;
+  refetchInterval?: number | false;
+  refetchOnWindowFocus?: boolean;
+};
+type UseConversationResult = {
+  conversation: GetConversationResponse["conversation"] | null;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: (args?: GetConversationRequest) => Promise<GetConversationResponse | undefined>;
+};
+declare function useConversation(conversationId: string | null, options?: UseConversationOptions): UseConversationResult;
+//#endregion
+export { UseConversationOptions, UseConversationResult, useConversation };
+//# sourceMappingURL=use-conversation.d.ts.map

package/use-conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversation.d.ts","names":[],"sources":["../../react/src/hooks/use-conversation.ts"],"sourcesContent":[],"mappings":";AAQY,KAAA,sBAAA,GAAsB;EAMtB,OAAA,CAAA,EAAA,OAAA;EAAqB,eAAA,CAAA,EAAA,MAAA,GAAA,KAAA;sBAClB,CAAA,EAAA,OAAA;;AAIN,KALG,qBAAA,GAKH;cACK,EALC,uBAKD,CAAA,cAAA,CAAA,GAAA,IAAA;WAAR,EAAA,OAAA;EAAO,KAAA,EAHL,KAGK,GAAA,IAAA;EAGG,OAAA,EAAA,CAAA,IAAe,CAAf,EAJP,sBAIsB,EAAA,GAHzB,OAGyB,CAHjB,uBAGiB,GAAA,SAAA,CAAA;CAAA;AAErB,iBAFM,eAAA,CAEN,cAAA,EAAA,MAAA,GAAA,IAAA,EAAA,OAAA,CAAA,EAAA,sBAAA,CAAA,EACP,qBADO"}

package/use-conversations.d.ts

@@ -0,0 +1,18 @@
+//#region ../react/src/hooks/use-conversations.d.ts
+
+type UseConversationsOptions = Partial<Omit<ListConversationsRequest, "visitorId">> & {
+  enabled?: boolean;
+  refetchInterval?: number | false;
+  refetchOnWindowFocus?: boolean;
+};
+type UseConversationsResult = {
+  conversations: ListConversationsResponse["conversations"];
+  pagination: ConversationPagination | null;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: (args?: Partial<ListConversationsRequest>) => Promise<ListConversationsResponse | undefined>;
+};
+declare function useConversations(options?: UseConversationsOptions): UseConversationsResult;
+//#endregion
+export { UseConversationsOptions, UseConversationsResult, useConversations };
+//# sourceMappingURL=use-conversations.d.ts.map

package/use-conversations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-conversations.d.ts","names":[],"sources":["../../react/src/hooks/use-conversations.ts"],"sourcesContent":[],"mappings":";;AA0CmC,KAAvB,uBAAA,GAA0B,OAAH,CAClC,IADkC,CAC7B,wBAD6B,EAAA,WAAA,CAAA,CAAA,GAAA;SAC7B,CAAA,EAAA,OAAA;iBAAL,CAAA,EAAA,MAAA,GAAA,KAAA;sBADqC,CAAA,EAAA,OAAA;CAAO;AAQjC,KAAA,sBAAA,GAAsB;EAAA,aAAA,EAClB,yBADkB,CAAA,eAAA,CAAA;YAClB,EACH,sBADG,GAAA,IAAA;WACH,EAAA,OAAA;OAEL,EAAA,KAAA,GAAA,IAAA;SAES,EAAA,CAAA,IAAA,CAAA,EAAR,OAAQ,CAAA,wBAAA,CAAA,EAAA,GACX,OADW,CACH,yBADG,GAAA,SAAA,CAAA;;AACH,iBAGE,gBAAA,CAHF,OAAA,CAAA,EAIJ,uBAJI,CAAA,EAKX,sBALW"}

package/use-create-conversation.d.ts

@@ -0,0 +1,26 @@
+//#region ../react/src/hooks/use-create-conversation.d.ts
+
+type UseCreateConversationOptions = {
+  client?: CossistantClient;
+  onSuccess?: (data: CreateConversationResponseBody) => void;
+  onError?: (error: Error) => void;
+};
+type CreateConversationVariables = {
+  conversationId?: string;
+  defaultTimelineItems?: TimelineItem[];
+  visitorId?: string;
+  websiteId?: string | null;
+  status?: Conversation["status"];
+  title?: string | null;
+};
+type UseCreateConversationResult = {
+  mutate: (variables?: CreateConversationVariables) => void;
+  mutateAsync: (variables?: CreateConversationVariables) => Promise<CreateConversationResponseBody | null>;
+  isPending: boolean;
+  error: Error | null;
+  reset: () => void;
+};
+declare function useCreateConversation(options?: UseCreateConversationOptions): UseCreateConversationResult;
+//#endregion
+export { CreateConversationVariables, UseCreateConversationOptions, UseCreateConversationResult, useCreateConversation };
+//# sourceMappingURL=use-create-conversation.d.ts.map

package/use-create-conversation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-create-conversation.d.ts","names":[],"sources":["../../react/src/hooks/use-create-conversation.ts"],"sourcesContent":[],"mappings":";;AASoB,KAFR,4BAAA,GAEQ;QACD,CAAA,EAFT,gBAES;EAAK,SAAA,CAAA,EAAA,CAAA,IAAA,EADJ,8BACI,EAAA,GAAA,IAAA;EAGZ,OAAA,CAAA,EAAA,CAAA,KAAA,EAHO,KAGP,EAAA,GAAA,IAA2B;CAAA;AAEf,KAFZ,2BAAA,GAEY;gBAGd,CAAA,EAAA,MAAA;EAAY,oBAAA,CAAA,EAHE,YAGF,EAAA;EAIV,SAAA,CAAA,EAAA,MAAA;EAA2B,SAAA,CAAA,EAAA,MAAA,GAAA,IAAA;QACjB,CAAA,EALZ,YAKY,CAAA,QAAA,CAAA;OAER,CAAA,EAAA,MAAA,GAAA,IAAA;;AACR,KAJM,2BAAA,GAIN;QAEE,EAAA,CAAA,SAAA,CAAA,EALc,2BAKd,EAAA,GAAA,IAAA;EAAK,WAAA,EAAA,CAAA,SAAA,CAAA,EAHC,2BAGD,EAAA,GAFP,OAEO,CAFC,8BAED,GAAA,IAAA,CAAA;EAgBG,SAAA,EAAA,OAAA;EAAqB,KAAA,EAhB7B,KAgB6B,GAAA,IAAA;OAC3B,EAAA,GAAA,GAAA,IAAA;;AACoB,iBAFd,qBAAA,CAEc,OAAA,CAAA,EADpB,4BACoB,CAAA,EAA3B,2BAA2B"}

package/use-default-messages.d.ts

@@ -0,0 +1,16 @@
+//#region ../react/src/hooks/private/use-default-messages.d.ts
+type UseDefaultMessagesParams = {
+  conversationId: string;
+};
+/**
+ * Mirrors the provider-configured default messages into timeline items so
+ * that welcome content renders immediately while the backend conversation is
+ * still being created. Agent fallbacks are resolved against available humans
+ * and AI agents exposed by the provider context.
+ */
+declare function useDefaultMessages({
+  conversationId
+}: UseDefaultMessagesParams): TimelineItem[];
+//#endregion
+export { useDefaultMessages };
+//# sourceMappingURL=use-default-messages.d.ts.map

package/use-default-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-default-messages.d.ts","names":[],"sources":["../../react/src/hooks/private/use-default-messages.ts"],"sourcesContent":[],"mappings":";AAEwE,KAInE,wBAAA,GAAwB;EAUb,cAAA,EAAA,MAAkB;CAAA;;;;;;;iBAAlB,kBAAA;;GAEb,2BAA2B"}

package/use-grouped-messages.d.ts

@@ -0,0 +1,51 @@
+//#region ../react/src/hooks/private/use-grouped-messages.d.ts
+
+type GroupedMessage = {
+  type: "message_group";
+  senderId: string;
+  senderType: SenderType;
+  items: TimelineItem[];
+  firstMessageId: string;
+  lastMessageId: string;
+  firstMessageTime: Date;
+  lastMessageTime: Date;
+};
+type TimelineEventItem = {
+  type: "timeline_event";
+  item: TimelineItem;
+  timestamp: Date;
+};
+type ConversationItem = GroupedMessage | TimelineEventItem;
+type UseGroupedMessagesOptions = {
+  items: TimelineItem[];
+  seenData?: ConversationSeen[];
+  currentViewerId?: string;
+  viewerType?: SenderType;
+};
+type UseGroupedMessagesProps = UseGroupedMessagesOptions;
+/**
+ * Batches sequential timeline items from the same sender into groups and enriches
+ * them with read-receipt helpers so UIs can render conversation timelines with
+ * minimal effort. Seen data is normalised into quick lookup maps for unread
+ * indicators.
+ */
+declare const useGroupedMessages: ({
+  items,
+  seenData,
+  currentViewerId,
+  viewerType
+}: UseGroupedMessagesOptions) => {
+  items: (GroupedMessage | TimelineEventItem)[];
+  seenByMap: Map<string, Set<string>>;
+  lastReadMessageMap: Map<string, string>;
+  unreadCountMap: Map<string, number>;
+  isMessageSeenByViewer: (messageId: string) => boolean;
+  getMessageSeenBy: (messageId: string) => string[];
+  getLastReadMessageId: (userId: string) => string | undefined;
+  isLastReadMessage: (messageId: string, userId: string) => boolean;
+  getUnreadCount: (userId: string) => number;
+  hasUnreadAfter: (messageId: string, userId: string) => boolean;
+};
+//#endregion
+export { ConversationItem, GroupedMessage, TimelineEventItem, UseGroupedMessagesOptions, UseGroupedMessagesProps, useGroupedMessages };
+//# sourceMappingURL=use-grouped-messages.d.ts.map

package/use-grouped-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-grouped-messages.d.ts","names":[],"sources":["../../react/src/hooks/private/use-grouped-messages.ts"],"sourcesContent":[],"mappings":";;AAQa,KAHD,cAAA,GAGC;MACL,EAAA,eAAA;UAGW,EAAA,MAAA;YACD,EALL,UAKK;EAAI,KAAA,EAJd,YAIc,EAAA;EAGV,cAAA,EAAA,MAAiB;EAAA,aAAA,EAAA,MAAA;kBAEtB,EANY,IAMZ;iBACK,EANM,IAMN;CAAI;AAGJ,KANA,iBAAA,GAMgB;EAAA,IAAA,EAAA,gBAAA;MAAG,EAJxB,YAIwB;WAAiB,EAHpC,IAGoC;CAAiB;AAErD,KAFA,gBAAA,GAAmB,cAEM,GAFW,iBAEX;AAAA,KAAzB,yBAAA,GAAyB;OAC7B,EAAA,YAAA,EAAA;UACI,CAAA,EAAA,gBAAA,EAAA;iBAEE,CAAA,EAAA,MAAA;EAAU,UAAA,CAAA,EAAV,UAAU;AAGxB,CAAA;AAuMa,KAvMD,uBAAA,GAA0B,yBA6PrC;;;;;;;cAtDY;;;;;GAKV"}