@natoe/colab 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,865 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import React from 'react';
+import { Channel } from 'phoenix';
+
+interface CollabConfig {
+    /** Phoenix WebSocket URL (e.g. wss://backend.natoe.ai/socket) */
+    socketUrl: string;
+    /** Returns the current JWT token for authentication */
+    getToken: () => string;
+    /** Current authenticated user */
+    userId: string;
+    userRole: UserRole;
+    userName: string;
+    userAvatar?: string;
+    /** Host app callbacks — colab calls these, never implements them */
+    onOpenDicom?: (studyId: string, storageId: string) => void;
+    onUploadFile?: (file: File | Blob, fileName?: string) => Promise<string>;
+    onDeepLink?: (path: string) => void;
+    onError?: (error: CollabError) => void;
+}
+type UserRole = 'lab' | 'radiologist' | 'physician' | 'admin';
+interface PatientData {
+    patientName: string;
+    patientAge?: string;
+    patientSex?: string;
+    studyType?: string;
+    studyId?: string;
+    storageId?: string;
+    referringPhysician?: string;
+    orderId: string;
+    displayOrderId?: string;
+    labName?: string;
+    bodyParts?: string[];
+}
+interface Conversation {
+    id: string;
+    orderId: string;
+    name: string;
+    picture?: string;
+    participants: Participant[];
+    lastMessage?: Message;
+    unreadCount: number;
+    createdAt: string;
+    updatedAt: string;
+    /** Denormalized patient data snapshot — lets UI render without extra fetch */
+    patientSnapshot?: PatientData;
+    /** Currently pinned messages (max 3) */
+    pinnedMessages?: Message[];
+}
+/**
+ * Lightweight item for the inbox conversation list.
+ * Sorted by the backend, typically by last activity descending.
+ */
+interface ConversationListItem$1 {
+    id: string;
+    orderId: string;
+    name: string;
+    picture?: string;
+    unreadCount: number;
+    lastMessage?: Message;
+    lastActivityAt: string;
+    patientSnapshot?: PatientData;
+}
+/**
+ * Lightweight preview of a conversation for inline rendering in table rows.
+ * Fetched in batch via requestPreview to avoid N+1 queries.
+ */
+interface ConversationPreview {
+    conversationId: string;
+    orderId: string;
+    messageCount: number;
+    unreadCount: number;
+    /** Last N messages (typically 5) for inline display */
+    lastMessages: Message[];
+    participants: Participant[];
+    name: string;
+}
+/** Batch preview response shape from the backend */
+interface PreviewBatchResponse {
+    /** Key is orderId, value is preview or null if no conversation exists */
+    previews: Record<string, ConversationPreview | null>;
+}
+/** Response from createConversationWithMessage (first-message flow) */
+interface CreateConversationResponse {
+    conversation: Conversation;
+    message: Message;
+}
+interface Participant {
+    userId: string;
+    userName: string;
+    userRole: UserRole;
+    avatar?: string;
+    isOnline?: boolean;
+    joinedAt: string;
+}
+type MessageType = 'text' | 'audio' | 'image' | 'file' | 'system' | 'deep_link';
+/**
+ * Denormalized snapshot of a message at the time it was quoted.
+ * Preserved on replies so the quoted context survives even if the original
+ * message is later deleted or edited.
+ */
+interface MessageSnapshot {
+    messageId: string;
+    senderId: string;
+    senderName: string;
+    body: string;
+    type: MessageType;
+}
+interface Message {
+    id: string;
+    conversationId: string;
+    senderId: string;
+    senderName: string;
+    senderRole: UserRole;
+    body: string;
+    type: MessageType;
+    mediaUrl?: string;
+    /** Duration in seconds for audio messages */
+    mediaDuration?: number;
+    /** Original file name for file messages */
+    fileName?: string;
+    metadata?: Record<string, unknown>;
+    insertedAt: string;
+    readBy?: string[];
+    /** When this message is a reply, the ID of the quoted message */
+    replyToId?: string;
+    /** Frozen snapshot of the quoted message */
+    replyToSnapshot?: MessageSnapshot;
+    /** Whether this message is pinned to the top of the thread */
+    isPinned?: boolean;
+    pinnedAt?: string;
+    pinnedBy?: string;
+}
+interface SendMessagePayload {
+    body: string;
+    type: MessageType;
+    mediaUrl?: string;
+    mediaDuration?: number;
+    fileName?: string;
+    metadata?: Record<string, unknown>;
+    /** ID of message being replied to (snapshot is built server-side) */
+    replyToId?: string;
+}
+type ChannelEvent = 'message:new' | 'message:read' | 'message:pinned' | 'message:unpinned' | 'user:typing' | 'user:joined' | 'user:left' | 'channel:updated' | 'channel:deleted';
+interface TypingEvent {
+    userId: string;
+    userName: string;
+    isTyping: boolean;
+}
+interface CollabError {
+    code: string;
+    message: string;
+    details?: unknown;
+}
+interface ChannelUpdatePayload {
+    name?: string;
+    picture?: string;
+}
+interface InviteUserPayload {
+    userId: string;
+    userName: string;
+    userRole: UserRole;
+}
+
+interface CollabPanelProps {
+    /** Order ID — one conversation per study */
+    orderId: string;
+    /** Patient/study data displayed in the header */
+    patientData: PatientData;
+    /** Participant user IDs — only used when creating a brand-new conversation */
+    participantIds?: string[];
+    /** Show "seen by" indicator under own messages (default true) */
+    showSeenBy?: boolean;
+    /** Custom class name for the outer container */
+    className?: string;
+    /** Custom inline styles for the outer container */
+    style?: React.CSSProperties;
+}
+/**
+ * Full collaboration panel: patient header + pinned bar + message thread + input.
+ * Supports reply, pin/unpin, and (optionally) seen-by indicators.
+ */
+declare function CollabPanel({ orderId, patientData, participantIds, showSeenBy, className, style, }: CollabPanelProps): react_jsx_runtime.JSX.Element;
+
+interface CollabPopupProps {
+    /** Order ID for this conversation */
+    orderId: string;
+    /** Patient/study data */
+    patientData: PatientData;
+    /** Participant user IDs — only used when creating a brand-new conversation */
+    participantIds?: string[];
+    /** Whether the popup is open */
+    isOpen: boolean;
+    /** Close the popup */
+    onClose: () => void;
+    /** Initial position (defaults to bottom-right) */
+    initialPosition?: {
+        x: number;
+        y: number;
+    };
+    /** Width of the popup */
+    width?: number;
+    /** Height of the popup */
+    height?: number;
+    className?: string;
+}
+/**
+ * Draggable floating chat popup — drop-in replacement for DraggableChatPopup.
+ * Renders a CollabPanel inside a movable, resizable container.
+ */
+declare function CollabPopup({ orderId, patientData, participantIds, isOpen, onClose, initialPosition, width, height, className, }: CollabPopupProps): react_jsx_runtime.JSX.Element | null;
+
+interface CollabInlineProps {
+    orderId: string;
+    patientData: PatientData;
+    /** User IDs to invite when the first message creates the conversation */
+    participantIds?: string[];
+    /** Called when user clicks the expand button — host opens the floating popup */
+    onExpand?: () => void;
+    /** Max inline messages to show (default 5) */
+    messageLimit?: number;
+    /** Placeholder text for the input */
+    placeholder?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Inline chat for table rows.
+ *
+ * Two states:
+ *   - No conversation yet: just an input bar (no socket, no preview)
+ *   - Conversation exists: last N messages + input + expand button
+ *
+ * Supports text and voice messages. File attachments and full chat features
+ * stay in the floating popup / inbox.
+ */
+declare function CollabInline({ orderId, patientData, participantIds, onExpand, messageLimit, placeholder, className, style, }: CollabInlineProps): react_jsx_runtime.JSX.Element;
+
+interface CollabInboxProps {
+    /** Optional: preselect a specific conversation (by conversation ID) */
+    initialConversationId?: string;
+    /** Optional callback when the user selects a conversation */
+    onSelectConversation?: (item: ConversationListItem$1) => void;
+    /** Title for the sidebar */
+    title?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * Full-page inbox — WhatsApp-style sidebar of all user's conversations
+ * with the selected conversation's CollabPanel on the right.
+ *
+ * Uses the same CollabPanel as the floating popup, so all features
+ * (reply, pin, seen-by, DICOM, voice, attachments) are available.
+ */
+declare function CollabInbox({ initialConversationId, onSelectConversation, title, className, style, }: CollabInboxProps): react_jsx_runtime.JSX.Element;
+
+type MessageCallback = (message: Message) => void;
+type TypingCallback = (event: TypingEvent) => void;
+type ParticipantCallback = (participant: Participant) => void;
+type ChannelUpdateCallback = (conversation: Partial<Conversation>) => void;
+type PresenceCallback = (presences: Record<string, {
+    userId: string;
+    isOnline: boolean;
+}>) => void;
+interface ConversationCallbacks {
+    onMessage?: MessageCallback;
+    onTyping?: TypingCallback;
+    onUserJoined?: ParticipantCallback;
+    onUserLeft?: ParticipantCallback;
+    onChannelUpdated?: ChannelUpdateCallback;
+    onChannelDeleted?: () => void;
+    onPresence?: PresenceCallback;
+    onMessageRead?: (data: {
+        messageId: string;
+        userId: string;
+    }) => void;
+    onMessagePinned?: (message: Message) => void;
+    onMessageUnpinned?: (data: {
+        messageId: string;
+    }) => void;
+}
+/**
+ * Manages Phoenix WebSocket connection and channel subscriptions.
+ * One instance per authenticated user session.
+ */
+declare class CollabSocket {
+    private socket;
+    private channels;
+    private presences;
+    private userChannel;
+    private config;
+    private onUnreadUpdate;
+    /** Connect to Phoenix WebSocket server. Idempotent — safe to call when
+     * the token becomes available later (e.g. after async login) without
+     * stacking up multiple open sockets. */
+    connect(config: CollabConfig): void;
+    /** Subscribe to user-level events (unread counts, notifications) */
+    private joinUserChannel;
+    /** Register callback for unread count changes */
+    onUnreadCountUpdate(callback: (counts: Record<string, number>) => void): void;
+    /** Join a conversation channel and subscribe to events */
+    joinConversation(conversationId: string, callbacks: ConversationCallbacks): Channel | null;
+    /** Leave a conversation channel */
+    leaveConversation(conversationId: string): void;
+    /** Send a message to a conversation.
+     *
+     * Phoenix buffers pushes fired while a channel is still joining and
+     * replays them on successful join. The default per-push timeout is 10s,
+     * which is tight on slow dev backends — we bump to 30s so a late join
+     * doesn't surface as a "timed out" error to a message that ultimately
+     * persists. The caller still gets 'ok' once the server acks.
+     */
+    sendMessage(conversationId: string, payload: SendMessagePayload): Promise<Message>;
+    /** Broadcast typing indicator */
+    sendTyping(conversationId: string, isTyping: boolean): void;
+    /** Mark messages as read */
+    markAsRead(conversationId: string, messageId: string): void;
+    /** Add a user to the conversation */
+    inviteUser(conversationId: string, payload: InviteUserPayload): Promise<Participant>;
+    /** Remove a user from the conversation */
+    removeUser(conversationId: string, userId: string): Promise<void>;
+    /** Update channel name/picture */
+    updateChannel(conversationId: string, payload: ChannelUpdatePayload): Promise<Conversation>;
+    /** Delete channel (admin only) */
+    deleteChannel(conversationId: string): Promise<void>;
+    /** Pin a message in the conversation (max MAX_PINNED_MESSAGES) */
+    pinMessage(conversationId: string, messageId: string): Promise<Message>;
+    /** Unpin a message in the conversation */
+    unpinMessage(conversationId: string, messageId: string): Promise<void>;
+    /** Generic push with promise wrapper */
+    private channelPush;
+    /** Check if connected */
+    isConnected(): boolean;
+    /** Disconnect socket and leave all channels */
+    disconnect(): void;
+}
+
+interface FetchMessagesOptions {
+    before?: string;
+    limit?: number;
+}
+interface CreateConversationOptions {
+    name: string;
+    participantIds?: string[];
+}
+interface CollabContextValue {
+    socket: CollabSocket;
+    config: CollabConfig;
+    apiBaseUrl: string;
+    totalUnread: number;
+    /** Batched preview lookup — coalesces calls within a microtask */
+    requestPreview: (orderId: string) => Promise<ConversationPreview | null>;
+    /** Invalidate a cached preview (e.g. when a new message arrives) */
+    invalidatePreview: (orderId: string) => void;
+    /** Fetch paginated message history */
+    fetchMessages: (conversationId: string, options?: FetchMessagesOptions) => Promise<Message[]>;
+    /** Atomic create-or-send — creates conversation if missing, then stores the first message */
+    createConversationWithMessage: (orderId: string, message: SendMessagePayload, options: CreateConversationOptions) => Promise<CreateConversationResponse>;
+    /** Add a user to an existing conversation (e.g. when radiologist is assigned later) */
+    addParticipant: (conversationId: string, userId: string) => Promise<void>;
+    /** Remove a user from a conversation */
+    removeParticipant: (conversationId: string, userId: string) => Promise<void>;
+    /** Fetch the current user's full conversation list — feeds the CollabInbox sidebar */
+    fetchConversationList: () => Promise<ConversationListItem$1[]>;
+    /** Pin a message (max MAX_PINNED_MESSAGES per conversation — backend enforces) */
+    pinMessage: (conversationId: string, messageId: string) => Promise<void>;
+    /** Unpin a message */
+    unpinMessage: (conversationId: string, messageId: string) => Promise<void>;
+    /** Fetch current pinned messages for a conversation */
+    fetchPinnedMessages: (conversationId: string) => Promise<Message[]>;
+}
+declare function useCollab(): CollabContextValue;
+interface CollabProviderProps {
+    config: CollabConfig;
+    children: React.ReactNode;
+    /** REST API base URL for the Phoenix backend (e.g. https://backend.natoe.ai) */
+    apiBaseUrl: string;
+}
+declare function CollabProvider({ config, apiBaseUrl, children }: CollabProviderProps): react_jsx_runtime.JSX.Element | null;
+
+interface UseConversationOptions {
+    orderId: string;
+    patientData: PatientData;
+    /** Participant user IDs used only when creating a brand-new conversation */
+    participantIds?: string[];
+    /** Load full history on mount (default true) */
+    loadHistory?: boolean;
+}
+interface UseConversationReturn {
+    conversation: Conversation | null;
+    messages: Message[];
+    pinnedMessages: Message[];
+    participants: Participant[];
+    typingUsers: TypingEvent[];
+    isLoading: boolean;
+    hasMore: boolean;
+    error: string | null;
+    isConnected: boolean;
+    /** Message currently being replied to (null if not replying) */
+    replyTo: Message | null;
+    /** Set/clear the active reply target */
+    setReplyTo: (message: Message | null) => void;
+    sendMessage: (body: string) => Promise<void>;
+    sendAudioMessage: (audioBlob: Blob, duration: number) => Promise<void>;
+    sendFileMessage: (file: File) => Promise<void>;
+    sendDeepLink: (path: string, label: string) => Promise<void>;
+    sendTyping: (isTyping: boolean) => void;
+    markAsRead: (messageId: string) => void;
+    loadMoreMessages: () => Promise<void>;
+    pinMessage: (messageId: string) => Promise<void>;
+    unpinMessage: (messageId: string) => Promise<void>;
+}
+/**
+ * Full conversation hook used by CollabPanel / CollabPopup.
+ *
+ * Lazy creation: the conversation is NOT created on mount. It's only created
+ * when the user sends the first message. If a conversation already exists for
+ * the given orderId, it's loaded and joined automatically.
+ */
+declare function useConversation({ orderId, patientData, participantIds, loadHistory, }: UseConversationOptions): UseConversationReturn;
+
+interface UseConversationListOptions {
+    /**
+     * When false, skips the initial auto-fetch. The caller can still invoke
+     * `refresh()` manually (e.g. on user interaction). Defaults to true.
+     */
+    enabled?: boolean;
+}
+interface UseConversationListReturn {
+    conversations: ConversationListItem$1[];
+    isLoading: boolean;
+    error: string | null;
+    refresh: () => Promise<void>;
+    /** Filter conversations by query string (matches channel name + patient name) */
+    filter: (query: string) => ConversationListItem$1[];
+    /** Total unread across all conversations */
+    totalUnread: number;
+}
+/**
+ * Fetches the current user's full conversation list for the inbox.
+ * Conversations are returned sorted by last activity (backend-sorted).
+ *
+ * Pass `{ enabled: false }` for lazy mode — useful when the list is behind
+ * a click (e.g. a collapsed FAB panel) and you don't want to hit the API
+ * until the user opens it.
+ */
+declare function useConversationList(options?: UseConversationListOptions): UseConversationListReturn;
+
+interface UseInlineCollabOptions {
+    orderId: string;
+    patientData: PatientData;
+    /** Participant IDs passed to the backend only when creating a new conversation */
+    participantIds?: string[];
+    /** Max messages to keep in inline state (default 5) */
+    messageLimit?: number;
+}
+interface UseInlineCollabReturn {
+    hasConversation: boolean;
+    messages: Message[];
+    participants: Participant[];
+    unreadCount: number;
+    isLoading: boolean;
+    isSubscribed: boolean;
+    error: string | null;
+    sendMessage: (body: string) => Promise<void>;
+    /** Send a voice message — uploads the blob via config.onUploadFile first */
+    sendAudioMessage: (audioBlob: Blob, duration: number) => Promise<void>;
+    /** Attach to the DOM element that represents the row — drives lazy socket subscription */
+    containerRef: (element: HTMLElement | null) => void;
+}
+/**
+ * Lightweight hook for inline chat in table rows.
+ *
+ * Behavior:
+ * - On mount: fetches preview (batched) — no socket work
+ * - If conversation exists AND row becomes visible: joins Phoenix channel (real-time)
+ * - If row scrolls out of view: leaves channel (frees resources)
+ * - First sendMessage creates conversation atomically + starts real-time flow
+ * - Subsequent sends go through the socket
+ */
+declare function useInlineCollab({ orderId, patientData, participantIds, messageLimit, }: UseInlineCollabOptions): UseInlineCollabReturn;
+
+interface UseMessagesOptions {
+    conversationId: string | null;
+    /** Initial page size (default 30) */
+    initialLimit?: number;
+}
+interface UseMessagesReturn {
+    messages: Message[];
+    isLoading: boolean;
+    hasMore: boolean;
+    error: string | null;
+    loadMore: () => Promise<void>;
+    addMessage: (message: Message) => void;
+    updateMessageReadBy: (messageId: string, userId: string) => void;
+    reset: () => void;
+}
+/**
+ * Standalone hook for message history management.
+ * Use this if you need message data outside of useConversation
+ * (e.g. building a completely custom UI).
+ */
+declare function useMessages({ conversationId, initialLimit, }: UseMessagesOptions): UseMessagesReturn;
+
+interface UseAudioRecorderReturn {
+    /** Whether the mic is currently recording */
+    isRecording: boolean;
+    /** Recording duration in seconds (updates every second while recording) */
+    duration: number;
+    /** Start recording from the microphone */
+    start: () => Promise<void>;
+    /** Stop recording and return the audio blob */
+    stop: () => Promise<{
+        blob: Blob;
+        duration: number;
+    } | null>;
+    /** Cancel recording without producing output */
+    cancel: () => void;
+    /** Whether the browser supports audio recording */
+    isSupported: boolean;
+    /** Error message if recording fails */
+    error: string | null;
+}
+/**
+ * Wraps the browser MediaRecorder API for voice message recording.
+ * Returns a blob suitable for uploading via config.onUploadFile.
+ */
+declare function useAudioRecorder(): UseAudioRecorderReturn;
+
+interface UseChannelSettingsOptions {
+    conversationId: string | null;
+}
+interface UseChannelSettingsReturn {
+    /** Invite a user to the conversation */
+    inviteUser: (payload: InviteUserPayload) => Promise<void>;
+    /** Remove a user from the conversation (admin/creator only) */
+    removeUser: (userId: string) => Promise<void>;
+    /** Current user leaves the conversation */
+    leaveChannel: () => Promise<void>;
+    /** Delete the conversation entirely (admin only) */
+    deleteChannel: () => Promise<void>;
+    /** Update channel name and/or picture */
+    updateChannel: (payload: ChannelUpdatePayload) => Promise<void>;
+    /** Whether an operation is in progress */
+    isUpdating: boolean;
+    /** Last error from any operation */
+    error: CollabError | null;
+    /** Whether current user can perform admin actions */
+    isAdmin: boolean;
+}
+declare function useChannelSettings({ conversationId }: UseChannelSettingsOptions): UseChannelSettingsReturn;
+
+interface UseUnreadCountReturn {
+    /** Total unread messages across all conversations */
+    totalUnread: number;
+    /** Get unread count for a specific conversation */
+    getCountForConversation: (conversationId: string) => number;
+    /** Manually clear unread count for a conversation (e.g. when user opens it) */
+    clearForConversation: (conversationId: string) => void;
+}
+/**
+ * Tracks unread message counts.
+ * Counts are pushed from the server via the user channel (no polling).
+ */
+declare function useUnreadCount(): UseUnreadCountReturn;
+
+interface ParsedDeepLink {
+    /** Full original link string */
+    raw: string;
+    /** The path after natoe:// (e.g. "order/4521") */
+    path: string;
+    /** The resource type (e.g. "order", "report", "dicom", "study") */
+    resource: string;
+    /** The resource ID */
+    id: string;
+}
+interface UseDeepLinksReturn {
+    /** Parse a deep link string into structured data */
+    parseDeepLink: (link: string) => ParsedDeepLink | null;
+    /** Handle a deep link click — calls config.onDeepLink or config.onOpenDicom */
+    handleDeepLink: (link: string) => void;
+    /** Check if a string contains deep links */
+    containsDeepLink: (text: string) => boolean;
+    /** Extract all deep links from a message body */
+    extractDeepLinks: (text: string) => ParsedDeepLink[];
+}
+/**
+ * Parses and handles natoe:// deep links in messages.
+ *
+ * Supported formats:
+ *   natoe://order/4521      → opens order detail
+ *   natoe://report/4521     → opens report
+ *   natoe://dicom/4521      → opens DICOM viewer (uses onOpenDicom callback)
+ *   natoe://study/4521      → opens study detail
+ */
+declare function useDeepLinks(): UseDeepLinksReturn;
+
+interface UsePinnedMessagesOptions {
+    conversationId: string | null;
+    /** Initial pinned messages from preview/initial load (avoids extra fetch) */
+    initial?: Message[];
+}
+interface UsePinnedMessagesReturn {
+    pinnedMessages: Message[];
+    isLoading: boolean;
+    error: string | null;
+    pin: (messageId: string) => Promise<void>;
+    unpin: (messageId: string) => Promise<void>;
+    /** Handlers to wire to socket pin/unpin events */
+    handlePinned: (message: Message) => void;
+    handleUnpinned: (messageId: string) => void;
+    refresh: () => Promise<void>;
+}
+/**
+ * Manages pinned messages for a conversation.
+ * Backend enforces MAX_PINNED_MESSAGES (3) — attempting to pin a 4th returns an error.
+ */
+declare function usePinnedMessages({ conversationId, initial, }: UsePinnedMessagesOptions): UsePinnedMessagesReturn;
+
+interface ConversationListProps {
+    conversations: ConversationListItem$1[];
+    selectedId: string | null;
+    isLoading: boolean;
+    error: string | null;
+    onSelect: (item: ConversationListItem$1) => void;
+    /** Optional title shown above the list */
+    title?: string;
+    className?: string;
+}
+/**
+ * Scrollable sidebar list of conversations with search and unread filter.
+ */
+declare function ConversationList({ conversations, selectedId, isLoading, error, onSelect, title, className, }: ConversationListProps): react_jsx_runtime.JSX.Element;
+
+interface ConversationListItemProps {
+    item: ConversationListItem$1;
+    isSelected: boolean;
+    onClick: () => void;
+    className?: string;
+}
+/**
+ * Single row in the inbox sidebar — shows patient/channel name, last message
+ * preview, timestamp, and unread badge.
+ */
+declare function ConversationListItem({ item, isSelected, onClick, className, }: ConversationListItemProps): react_jsx_runtime.JSX.Element;
+
+interface PatientHeaderProps {
+    patientData: PatientData;
+    participants: Participant[];
+    onOpenDicom?: () => void;
+    onOpenSettings?: () => void;
+    className?: string;
+}
+declare function PatientHeader({ patientData, onOpenDicom, onOpenSettings, className, }: PatientHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface MessageListHandle {
+    /** Scroll to a specific message by ID (used by pin jump-to) */
+    scrollToMessage: (messageId: string) => void;
+}
+interface MessageListProps {
+    messages: Message[];
+    currentUserId: string;
+    participants?: Participant[];
+    showSeenBy?: boolean;
+    typingUsers: TypingEvent[];
+    hasMore: boolean;
+    isLoading: boolean;
+    onLoadMore: () => void;
+    onDeepLinkClick?: (link: string) => void;
+    onMessageVisible?: (messageId: string) => void;
+    onReply?: (message: Message) => void;
+    onPin?: (messageId: string) => void;
+    onUnpin?: (messageId: string) => void;
+    onCopy?: (text: string) => void;
+    pinDisabled?: boolean;
+    className?: string;
+}
+declare const MessageList: React.ForwardRefExoticComponent<MessageListProps & React.RefAttributes<MessageListHandle>>;
+
+interface MessageBubbleProps {
+    message: Message;
+    isOwn: boolean;
+    /** Participants list — needed for SeenByIndicator */
+    participants?: Participant[];
+    /** Current user ID — needed for SeenByIndicator */
+    currentUserId?: string;
+    /** Show "seen by" indicator under own messages (default true — inline disables this) */
+    showSeenBy?: boolean;
+    onDeepLinkClick?: (link: string) => void;
+    onReply?: (message: Message) => void;
+    onPin?: (messageId: string) => void;
+    onUnpin?: (messageId: string) => void;
+    onCopy?: (text: string) => void;
+    onReplyJumpTo?: (messageId: string) => void;
+    /** True if pin limit reached — disables pin action */
+    pinDisabled?: boolean;
+    className?: string;
+}
+declare function MessageBubble({ message, isOwn, participants, currentUserId, showSeenBy, onDeepLinkClick, onReply, onPin, onUnpin, onCopy, onReplyJumpTo, pinDisabled, className, }: MessageBubbleProps): react_jsx_runtime.JSX.Element;
+
+interface MessageInputProps {
+    onSendText: (body: string) => Promise<void>;
+    onSendAudio: (blob: Blob, duration: number) => Promise<void>;
+    onSendFile: (file: File) => Promise<void>;
+    onTyping: (isTyping: boolean) => void;
+    /** When set, shows a ReplyPreview above the input */
+    replyTo?: Message | null;
+    /** Called when user cancels the reply */
+    onCancelReply?: () => void;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+}
+declare function MessageInput({ onSendText, onSendAudio, onSendFile, onTyping, replyTo, onCancelReply, disabled, placeholder, className, }: MessageInputProps): react_jsx_runtime.JSX.Element;
+
+interface MessageActionsMenuProps {
+    message: Message;
+    onReply: (message: Message) => void;
+    onPin: (messageId: string) => void;
+    onUnpin: (messageId: string) => void;
+    onCopy?: (text: string) => void;
+    /** True when the menu should show (hover / open state managed by parent) */
+    visible: boolean;
+    /** Whether we've hit the pin limit — if true, pin is disabled */
+    pinDisabled?: boolean;
+    className?: string;
+}
+/**
+ * Inline action menu for a single message.
+ * Parent controls visibility (typically via hover state in MessageBubble).
+ */
+declare function MessageActionsMenu({ message, onReply, onPin, onUnpin, onCopy, visible, pinDisabled, className, }: MessageActionsMenuProps): react_jsx_runtime.JSX.Element | null;
+
+interface ReplyPreviewProps {
+    /** The message being replied to */
+    message: Message;
+    /** Called when user cancels the reply */
+    onCancel: () => void;
+    className?: string;
+}
+/**
+ * Shown above the MessageInput when the user is composing a reply.
+ * Displays the quoted message with a cancel button.
+ */
+declare function ReplyPreview({ message, onCancel, className }: ReplyPreviewProps): react_jsx_runtime.JSX.Element;
+
+interface ReplyQuoteBlockProps {
+    snapshot: MessageSnapshot;
+    /** True when rendered inside an own-message bubble (affects color contrast) */
+    inOwnBubble?: boolean;
+    /** Called when user clicks the quote — host can scroll to the original message */
+    onClick?: (messageId: string) => void;
+    className?: string;
+}
+/**
+ * Rendered inside a MessageBubble when the message is a reply.
+ * Shows a compact quote of the original message.
+ */
+declare function ReplyQuoteBlock({ snapshot, inOwnBubble, onClick, className, }: ReplyQuoteBlockProps): react_jsx_runtime.JSX.Element;
+
+interface SeenByIndicatorProps {
+    /** User IDs who have read the message */
+    readBy: string[];
+    /** All participants in the conversation — used to resolve names */
+    participants: Participant[];
+    /** Current user ID (excluded from the display) */
+    currentUserId: string;
+    /** Message sender ID (excluded from the display) */
+    senderId: string;
+    className?: string;
+}
+/**
+ * WhatsApp-style "Seen by" indicator shown under own messages.
+ * Shows up to 3 names inline; if more, shows remainder count with a tap-to-expand.
+ *
+ * Only renders when the current user is the sender (seen-by on others' messages
+ * is redundant — they obviously saw their own message).
+ */
+declare function SeenByIndicator({ readBy, participants, currentUserId, senderId, className, }: SeenByIndicatorProps): react_jsx_runtime.JSX.Element | null;
+
+interface PinnedMessagesBarProps {
+    pinnedMessages: Message[];
+    /** Clicking a pinned message scrolls to it in the thread */
+    onJumpTo: (messageId: string) => void;
+    /** Called when user unpins a message */
+    onUnpin: (messageId: string) => void;
+    className?: string;
+}
+/**
+ * Horizontal strip at the top of the thread showing pinned messages (max 3).
+ * Cycles through them on click if more than one.
+ */
+declare function PinnedMessagesBar({ pinnedMessages, onJumpTo, onUnpin, className, }: PinnedMessagesBarProps): react_jsx_runtime.JSX.Element | null;
+
+interface ChannelSettingsProps {
+    conversationId: string;
+    channelName: string;
+    channelPicture?: string;
+    participants: Participant[];
+    currentUserId: string;
+    isAdmin: boolean;
+    isUpdating: boolean;
+    error: CollabError | null;
+    onUpdateChannel: (payload: {
+        name?: string;
+        picture?: string;
+    }) => Promise<void>;
+    onInviteUser: (payload: InviteUserPayload) => Promise<void>;
+    onRemoveUser: (userId: string) => Promise<void>;
+    onLeaveChannel: () => Promise<void>;
+    onDeleteChannel: () => Promise<void>;
+    onClose: () => void;
+    className?: string;
+}
+declare function ChannelSettings({ channelName, participants, currentUserId, isAdmin, isUpdating, error, onUpdateChannel, onInviteUser, onRemoveUser, onLeaveChannel, onDeleteChannel, onClose, className, }: ChannelSettingsProps): react_jsx_runtime.JSX.Element;
+
+interface ParticipantsListProps {
+    participants: Participant[];
+    currentUserId: string;
+    isAdmin: boolean;
+    onRemoveUser: (userId: string) => Promise<void>;
+    className?: string;
+}
+declare function ParticipantsList({ participants, currentUserId, isAdmin, onRemoveUser, className, }: ParticipantsListProps): react_jsx_runtime.JSX.Element;
+
+/** Phoenix channel event names — must match backend channel implementation */
+declare const EVENTS: {
+    readonly MESSAGE_NEW: "message:new";
+    readonly MESSAGE_READ: "message:read";
+    readonly MESSAGE_PINNED: "message:pinned";
+    readonly MESSAGE_UNPINNED: "message:unpinned";
+    readonly USER_TYPING: "user:typing";
+    readonly USER_JOINED: "user:joined";
+    readonly USER_LEFT: "user:left";
+    readonly CHANNEL_UPDATED: "channel:updated";
+    readonly CHANNEL_DELETED: "channel:deleted";
+    readonly PRESENCE_STATE: "presence_state";
+    readonly PRESENCE_DIFF: "presence_diff";
+};
+/** Maximum number of pinned messages allowed per conversation */
+declare const MAX_PINNED_MESSAGES = 3;
+/** Message types */
+declare const MESSAGE_TYPES: {
+    readonly TEXT: "text";
+    readonly AUDIO: "audio";
+    readonly IMAGE: "image";
+    readonly FILE: "file";
+    readonly SYSTEM: "system";
+    readonly DEEP_LINK: "deep_link";
+};
+/** Deep link protocol prefix */
+declare const DEEP_LINK_PREFIX = "natoe://";
+/** Typing indicator debounce in ms */
+declare const TYPING_DEBOUNCE_MS = 2000;
+/** Messages to load per page when scrolling back */
+declare const MESSAGES_PAGE_SIZE = 30;
+/** Supported audio MIME type for recording */
+declare const AUDIO_MIME_TYPE = "audio/webm;codecs=opus";
+/** Supported image types for attachments */
+declare const SUPPORTED_IMAGE_TYPES: string[];
+/** Max file size in bytes (20MB) */
+declare const MAX_FILE_SIZE: number;
+
+export { AUDIO_MIME_TYPE, type ChannelEvent, ChannelSettings, type ChannelUpdatePayload, type CollabConfig, type CollabError, CollabInbox, CollabInline, CollabPanel, CollabPopup, CollabProvider, CollabSocket, type Conversation, ConversationList, ConversationListItem, type ConversationListItem$1 as ConversationListItemData, type ConversationPreview, type CreateConversationResponse, DEEP_LINK_PREFIX, EVENTS, type InviteUserPayload, MAX_FILE_SIZE, MAX_PINNED_MESSAGES, MESSAGES_PAGE_SIZE, MESSAGE_TYPES, type Message, MessageActionsMenu, MessageBubble, MessageInput, MessageList, type MessageListHandle, type MessageSnapshot, type MessageType, type Participant, ParticipantsList, type PatientData, PatientHeader, PinnedMessagesBar, type PreviewBatchResponse, ReplyPreview, ReplyQuoteBlock, SUPPORTED_IMAGE_TYPES, SeenByIndicator, type SendMessagePayload, TYPING_DEBOUNCE_MS, type TypingEvent, type UserRole, useAudioRecorder, useChannelSettings, useCollab, useConversation, useConversationList, useDeepLinks, useInlineCollab, useMessages, usePinnedMessages, useUnreadCount };