@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/dist/thread-oPra7pkW.d.ts

@@ -0,0 +1,57 @@
+import { q as ChatMessage, B as PendingMessage, g as ChatActivity } from './client-DUIG1hum.js';
+
+/**
+ * @feat:chat
+ * Pure thread logic, the same on every platform: merging the server's messages
+ * with ones still on their way, grouping a run of messages from one sender,
+ * day dividers, the unread line, reactions by emoji, and the typing line.
+ */
+
+type ThreadItem = {
+    type: "message";
+    message: ChatMessage;
+    pending?: undefined;
+} | {
+    type: "pending";
+    pending: PendingMessage;
+    message?: undefined;
+};
+/**
+ * The server's messages (by seq), then what is still sending, oldest first. A
+ * pending message the server already has (same clientId) is dropped, so a send
+ * that landed never shows twice.
+ */
+declare function mergeThread(server: ChatMessage[], pending: PendingMessage[]): ThreadItem[];
+/** Adds or replaces messages in a page, keeping it sorted and free of duplicates. */
+declare function upsertMessages(existing: ChatMessage[], incoming: ChatMessage[]): ChatMessage[];
+declare function itemSender(item: ThreadItem): string | null;
+declare function itemTime(item: ThreadItem): string;
+/** Runs of one sender within five minutes share a header (name, avatar). */
+declare function startsGroup(items: ThreadItem[], index: number, gapMs?: number): boolean;
+declare function sameDay(a: string, b: string): boolean;
+/** A day divider goes before this item. */
+declare function startsDay(items: ThreadItem[], index: number): boolean;
+/** "Today", "Yesterday", "Monday", or "12 Mar 2026". */
+declare function dayLabel(iso: string, now?: Date, locale?: string): string;
+/** The first message after what you had read, from someone else: where "New" goes. */
+declare function firstUnreadId(messages: ChatMessage[], lastReadSeq: number, me: string): string | null;
+interface ReactionSummary {
+    emoji: string;
+    count: number;
+    mine: boolean;
+    userIds: string[];
+}
+/** Reactions by emoji, most first, then in first-used order. */
+declare function summarizeReactions(message: ChatMessage, me: string): ReactionSummary[];
+/** Who is doing what now: activity older than six seconds has stopped. */
+declare function currentActivity(activity: ChatActivity[], now?: number, staleMs?: number): ChatActivity[];
+/** "Sam is typing…", "Sam and Lee are typing…", "Sam is recording a voice message…". */
+declare function activityLine(activity: ChatActivity[], nameOf: (userId: string) => string): string | null;
+/** Sends activity at most once every `everyMs`. */
+declare function throttle(fn: () => void, everyMs?: number): () => void;
+/** The ids @mentioned in markdown written as `@[Name](user:<uuid>)`. */
+declare function parseMentions(body: string): string[];
+/** A one-line preview: text, or what was attached. */
+declare function previewText(body: string, attachment: string | null | undefined, deleted?: boolean): string;
+
+export { type ReactionSummary as R, type ThreadItem as T, activityLine as a, itemTime as b, currentActivity as c, dayLabel as d, previewText as e, firstUnreadId as f, startsDay as g, startsGroup as h, itemSender as i, summarizeReactions as j, mergeThread as m, parseMentions as p, sameDay as s, throttle as t, upsertMessages as u };

package/dist/web.d.ts

@@ -1,9 +1,10 @@
 import * as react from 'react';
-import { ComponentType, ReactNode, Ref } from 'react';
+import { ComponentType, ReactNode, Ref, Component, ErrorInfo } from 'react';
 import { SlotOverride } from '@marktiderman/genesis-core/slots';
-import { e as ChatMessage, h as ChatInboxItem, j as ChatAttachment, a as ChatConversation, b as ChatMember, c as ChatRole, C as ChatClient, f as ChatActivity } from './client-BtdALFCx.js';
-import { ConversationState } from './react.js';
-import { ThreadItem, LocalFile } from './index.js';
+import { q as ChatMessage, m as ChatInboxItem, o as ChatLinkPreview$1, h as ChatAttachment, k as ChatConversation, p as ChatMember, t as ChatRole, i as ChatClient, g as ChatActivity, C as ChatAvailability, x as ChatTopic, T as TopicInput, u as ChatSearchHit, F as SendInput, A as AttachmentInput } from './client-DUIG1hum.js';
+import { ChatAttachmentKind, ConversationState, ChatVideoUpload } from './react.js';
+import { T as ThreadItem } from './thread-oPra7pkW.js';
+import { L as LocalFile } from './outbox-B9NAWQ58.js';
 import '@supabase/supabase-js';
 import '@tanstack/query-core';
 
@@ -49,6 +50,46 @@ interface ChatInboxProps {
 declare function inboxTitle(item: ChatInboxItem, resolveUser: ResolveUser, fallback?: (item: ChatInboxItem) => string): string;
 declare function ChatInbox({ resolveUser, onSelect, selectedId, kind, archived, fallbackTitle, slots, className, ...rest }: ChatInboxProps): react.JSX.Element;
 
+/**
+ * Whether a link preview shows its image. The image lives on the linked site, so loading it
+ * straight from there tells that site each reader's IP address and when they read the message
+ * (a tracking pixel the sender controls). So:
+ * - `"off"` (the default): no image;
+ * - `"proxy"`: through your own image proxy, `proxyUrl(imageUrl)`; no image without it;
+ * - `"direct"`: from the linked site (only if you accept that).
+ */
+type LinkPreviewImages = "off" | "proxy" | "direct";
+/** The image a preview may show under this setting, or null. Only https image URLs are ever considered. */
+declare function linkPreviewImageSrc(imageUrl: string | null | undefined, images?: LinkPreviewImages, proxyUrl?: (url: string) => string | null | undefined): string | null;
+interface ChatLinkPreviewProps {
+    preview: ChatLinkPreview$1;
+    /** Whether to show its image, and how; `"off"` by default (see LinkPreviewImages). */
+    images?: LinkPreviewImages;
+    /** Your image proxy, for `images: "proxy"`: the URL to load instead of the linked site's. */
+    proxyUrl?: (url: string) => string | null | undefined;
+    tone?: "default" | "primary";
+    className?: string;
+}
+declare function ChatLinkPreview({ preview, images, proxyUrl, tone, className }: ChatLinkPreviewProps): react.JSX.Element | null;
+interface ChatAttachmentCardProps {
+    title: string;
+    subtitle?: string | null;
+    /** An icon component (lucide); a clipboard by default. */
+    icon?: ComponentType<{
+        className?: string;
+    }>;
+    /** One button: a link (`href`, safe schemes only) or a handler. */
+    action?: {
+        label: string;
+        href?: string;
+        onPress?: () => void;
+    } | null;
+    tone?: "default" | "primary";
+    className?: string;
+}
+/** A card for an app's own attachment kind: an icon, a title, a subtitle and one action. */
+declare function ChatAttachmentCard({ title, subtitle, icon: Icon, action, tone, className }: ChatAttachmentCardProps): react.JSX.Element;
+
 /** One attachment as the renderers draw it, sent or still uploading. */
 interface AttachmentView {
     key: string;
@@ -95,6 +136,7 @@ interface LightboxProps {
 }
 /** A photo full size, with the previous and next ones on the arrow keys. */
 declare function Lightbox({ images, index, onIndexChange }: LightboxProps): react.JSX.Element;
+/** A video: a hosted one (Mux) streams once ready and says "Processing…" until then; a file plays from storage. */
 declare function VideoAttachment({ view }: {
     view: AttachmentView;
 }): react.JSX.Element;
@@ -109,9 +151,11 @@ interface MessageAttachmentsProps {
     tone: "default" | "primary";
     /** For kinds the package doesn't draw; a generic card by default. */
     slot?: ComponentType<ChatAttachmentSlotProps> | null;
+    /** Cards for registered app kinds (ChatProvider `attachmentKinds`), drawn before the slot. */
+    kinds?: Record<string, ChatAttachmentKind>;
 }
 /** Every attachment of one message, photos grouped into one grid. */
-declare function MessageAttachments({ views, message, mine, tone, slot }: MessageAttachmentsProps): react.JSX.Element | null;
+declare function MessageAttachments({ views, message, mine, tone, slot, kinds }: MessageAttachmentsProps): react.JSX.Element | null;
 
 interface ChatThreadHeaderProps {
     conversationId: string;
@@ -129,6 +173,8 @@ interface ChatThreadHeaderProps {
     resolveUser: ResolveUser;
     onBack?: () => void;
     backClassName?: string;
+    /** Opens search in this conversation (absent when search is off). */
+    onSearch?: () => void;
 }
 interface ChatThreadEmptyProps {
     conversationId: string;
@@ -163,15 +209,43 @@ interface ChatThreadProps {
     threadRootId?: string;
     /** One topic's messages. */
     topic?: string;
-    /** Shown on messages that have replies, to open their thread. */
-    onOpenThread?: (message: ChatMessage) => void;
+    /**
+     * Shown on messages that have replies, to open their thread. Also called when a search result
+     * is a reply in a thread, with `jumpTo` (that reply) for the thread's own ChatThread.
+     */
+    onOpenThread?: (message: ChatMessage, opts?: {
+        jumpTo?: {
+            messageId: string;
+            seq: number;
+        };
+    }) => void;
     /** The quick reactions; 👍 ❤️ 😂 😮 😢 🙏 by default. */
     quickReactions?: readonly string[];
     placeholder?: string;
+    /** Show the topic bar even before the first topic exists (so an owner can add one). */
+    showTopics?: boolean;
+    /** Scroll to this message once it's loaded (a search result across conversations); `seq` lets earlier pages load to reach it. */
+    jumpTo?: {
+        messageId: string;
+        seq?: number;
+        threadRootId?: string | null;
+    } | null;
+    /** A search button in the header. Default true. */
+    search?: boolean;
+    /** Scheduled send in the composer. Default true. */
+    scheduling?: boolean;
+    /** The away banner. Default true. */
+    availability?: boolean;
+    /** Where the emoji picker loads its data from (self-hosted emojibase-data). Without it there is no full picker; the quick reactions stay. */
+    emojibaseUrl?: string;
+    /** Link preview images: `"off"` by default, `"proxy"` through `linkPreviewProxyUrl`, or `"direct"` from the linked site (which then sees readers' IPs). */
+    linkPreviewImages?: LinkPreviewImages;
+    /** Your image proxy for `linkPreviewImages: "proxy"`: the URL to load for an og:image. */
+    linkPreviewProxyUrl?: (url: string) => string | null | undefined;
     slots?: ChatThreadSlots;
     className?: string;
 }
-declare function ChatThread({ conversationId, resolveUser, title: titleProp, onBack, backClassName, threadRootId, topic, onOpenThread, quickReactions, placeholder, slots, className, }: ChatThreadProps): react.JSX.Element;
+declare function ChatThread({ conversationId, resolveUser, title: titleProp, onBack, backClassName, threadRootId, topic: topicProp, onOpenThread, quickReactions, placeholder, showTopics, jumpTo: jumpToProp, search, scheduling, availability, emojibaseUrl, linkPreviewImages, linkPreviewProxyUrl, slots, className, }: ChatThreadProps): react.JSX.Element;
 
 interface ChatPanelNoSelectionProps {
     /** Words under the title; "Pick one on the left to read and reply." by default. */
@@ -193,9 +267,11 @@ interface ChatPanelProps {
     slots?: {
         noSelection?: SlotOverride<ChatPanelNoSelectionProps>;
     };
+    /** Search across every conversation, above the inbox. Default true. */
+    search?: boolean;
     className?: string;
 }
-declare function ChatPanel({ resolveUser, selectedId: controlled, defaultSelectedId, onSelectedChange, inboxHeader, inboxProps, threadProps, slots, className, }: ChatPanelProps): react.JSX.Element;
+declare function ChatPanel({ resolveUser, selectedId: controlled, defaultSelectedId, onSelectedChange, inboxHeader, inboxProps, threadProps, slots, search, className, }: ChatPanelProps): react.JSX.Element;
 
 interface ChatComposerHandle {
     /** Adds files as if picked (a drop on the thread, say). Refused ones get a toast. */
@@ -206,7 +282,7 @@ interface ChatComposerHandle {
 }
 interface ChatComposerProps {
     /** From `useConversation`: how to send, and whether you may. */
-    conversation: Pick<ConversationState, "send" | "signalTyping" | "signalRecording" | "role" | "canPost" | "accessLoading" | "conversation">;
+    conversation: Pick<ConversationState, "send" | "signalTyping" | "signalRecording" | "role" | "canPost" | "accessLoading" | "conversation"> & Partial<Pick<ConversationState, "accessError" | "refetchAccess" | "signalRecordingVideo" | "conversationLoading">>;
     /** The message being replied to; a banner shows above the box. */
     replyTo?: ChatMessage | null;
     onCancelReply?: () => void;
@@ -218,10 +294,22 @@ interface ChatComposerProps {
     /** Called after a message is queued. */
     onSent?: () => void;
     autoFocus?: boolean;
+    /** Shown instead of the box, with a lock (a closed topic). */
+    disabledReason?: string | null;
+    /** The topic new messages go to (scheduled ones too). */
+    topic?: string | null;
+    /** Offer scheduled send (the arrow beside Send) and list what's scheduled. Default true. */
+    scheduling?: boolean;
+    /** Offer video recording. Default true where the browser can record. */
+    video?: boolean;
+    /** Offer the emoji picker (only when `emojibaseUrl` is given). Default true. */
+    emoji?: boolean;
+    /** Where the emoji picker loads its data from. */
+    emojibaseUrl?: string;
     className?: string;
     ref?: Ref<ChatComposerHandle>;
 }
-declare function ChatComposer({ conversation: state, replyTo, onCancelReply, resolveUser, placeholder, accessory, onSent, autoFocus, className, ref, }: ChatComposerProps): react.JSX.Element;
+declare function ChatComposer({ conversation: state, replyTo, onCancelReply, resolveUser, placeholder, accessory, onSent, autoFocus, disabledReason, topic, scheduling, video, emoji, emojibaseUrl, className, ref, }: ChatComposerProps): react.JSX.Element;
 
 interface MessageRowProps {
     item: ThreadItem;
@@ -357,6 +445,12 @@ interface MemoryConversationSeed {
         attachments?: Partial<ChatAttachment>[];
     })[];
     pins?: string[];
+    /** Its topics, in order. */
+    topics?: {
+        topic: string;
+        title?: string;
+        closed?: boolean;
+    }[];
 }
 interface MemoryChatOptions {
     /** The signed-in user. */
@@ -366,6 +460,10 @@ interface MemoryChatOptions {
     files?: Record<string, string>;
     /** Milliseconds each call waits, to show loading states. Default 0. */
     latencyMs?: number;
+    /** Away messages and working hours, by user id. */
+    availability?: Record<string, Partial<Omit<ChatAvailability, "userId">>>;
+    /** Link previews the "server" has fetched. */
+    linkPreviews?: Partial<ChatLinkPreview$1>[];
 }
 type MemoryChatClient = ChatClient & {
     /** Someone else posts (a demo's other side). */
@@ -376,6 +474,10 @@ type MemoryChatClient = ChatClient & {
     failNextSends(count?: number): void;
     /** The next send waits until the returned function is called (a test watching the sending state). */
     holdNextSend(): () => void;
+    /** Posts every scheduled message due by `now` (a demo's clock), as the server's runner does. */
+    sendDue(now?: Date): Promise<number>;
+    /** Moderation's verdict on a message (the server's side). */
+    moderate(messageId: string, result: "clean" | "flagged" | "hidden"): void;
     /** Every call made, for tests. */
     calls: {
         method: string;
@@ -384,4 +486,225 @@ type MemoryChatClient = ChatClient & {
 };
 declare function createMemoryChatClient(options: MemoryChatOptions): MemoryChatClient;
 
-export { type AttachmentView, type ChatAttachmentSlotProps, ChatComposer, type ChatComposerAccessoryProps, type ChatComposerHandle, type ChatComposerProps, ChatInbox, type ChatInboxEmptyProps, type ChatInboxProps, ChatMarkdown, type ChatMarkdownProps, ChatPanel, type ChatPanelNoSelectionProps, type ChatPanelProps, ChatThread, type ChatThreadEmptyProps, type ChatThreadHeaderProps, type ChatThreadProps, type ChatThreadSlots, type ChatUser, FileChip, GenericAttachment, ImageGrid, type ImageGridProps, Lightbox, type LightboxProps, type MarkdownNode, type MemoryChatClient, type MemoryChatOptions, type MemoryConversationSeed, MessageAttachments, type MessageAttachmentsProps, MessageRow, type MessageRowProps, QUICK_REACTIONS, type ResolveUser, type UseVoiceRecorderOptions, VideoAttachment, VoiceNote, type VoiceNoteProps, type VoiceRecorder, type VoiceRecorderState, type VoiceRecording, clockTime, createMemoryChatClient, formatBytes, inboxTitle, isSafeHref, messageLabel, parseMarkdown, pickVoiceMimeType, plainText, relativeTime, toAttachmentView, useVoiceRecorder, voiceFile };
+interface ChatTopicBarProps {
+    topics: ChatTopic[];
+    /** The topic shown; null for "All". */
+    value: string | null;
+    onValueChange: (topic: string | null) => void;
+    /** Owners and admins: "New topic", and close or reopen. */
+    canManage?: boolean;
+    /** Saves a topic (from useTopics). */
+    onSetTopic?: (topic: string, input: TopicInput) => Promise<void>;
+    className?: string;
+}
+declare function ChatTopicBar({ topics, value, onValueChange, canManage, onSetTopic, className }: ChatTopicBarProps): react.JSX.Element;
+
+interface ChatScheduleMenuProps {
+    /** Called with the chosen time. */
+    onSchedule: (at: Date) => void;
+    disabled?: boolean;
+    /** For tests and demos. */
+    now?: Date;
+}
+/** `YYYY-MM-DDTHH:mm` in local time, for a datetime-local input. */
+declare function toLocalInput(d: Date): string;
+/** The chevron beside Send: "Schedule message" with quick picks and a custom time. */
+declare function ChatScheduleMenu({ onSchedule, disabled, now }: ChatScheduleMenuProps): react.JSX.Element;
+interface ChatScheduledListProps {
+    /** One conversation's; all of yours without it. */
+    conversationId?: string | null;
+    /** Names a conversation in the all-conversations list. */
+    conversationTitle?: (conversationId: string) => string;
+    className?: string;
+}
+/** Your scheduled messages, soonest first, each with when it goes and Cancel (Remove for one that failed). */
+declare function ChatScheduledList({ conversationId, conversationTitle, className }: ChatScheduledListProps): react.JSX.Element;
+
+interface ChatAwayBannerProps {
+    /** One person (a direct conversation). */
+    availability?: ChatAvailability | null;
+    /** The person's name, as the app shows it. */
+    name?: string;
+    /** Several people (a group): everyone away or outside their hours is named, two at most. */
+    people?: {
+        availability: ChatAvailability | null | undefined;
+        name: string;
+    }[];
+    now?: Date;
+    className?: string;
+}
+/** "Mark replies Mon–Fri, 9–5 (Eastern)", "Away until Monday: Back Monday", "Sam, Lee and 2 others are away"; nothing when everyone is around. */
+declare function ChatAwayBanner({ availability, name, people, now, className }: ChatAwayBannerProps): react.JSX.Element | null;
+interface ChatAvailabilitySettingsProps {
+    /** Called after a save. */
+    onSaved?: () => void;
+    className?: string;
+}
+/**
+ * Your availability: an away message (and until when), working hours per weekday, and the
+ * time zone they're read in. One range per day here; extra ranges saved elsewhere are kept
+ * for the days you don't change.
+ */
+declare function ChatAvailabilitySettings({ onSaved, className }: ChatAvailabilitySettingsProps): react.JSX.Element;
+
+interface ChatBroadcastProps {
+    resolveUser: ResolveUser;
+    /** Only this kind of conversation (`direct`, say). */
+    kind?: string;
+    /** Which inbox rows may be picked; every one by default. */
+    filter?: (item: ChatInboxItem) => boolean;
+    /** Called with how many it went to. */
+    onSent?: (sent: number, picked: number) => void;
+    className?: string;
+}
+declare function ChatBroadcast({ resolveUser, kind, filter, onSent, className }: ChatBroadcastProps): react.JSX.Element;
+
+interface ChatSearchProps {
+    resolveUser: ResolveUser;
+    /** Search one conversation; all of yours without it. */
+    conversationId?: string | null;
+    /** Called with the chosen result. */
+    onOpen: (hit: ChatSearchHit) => void;
+    /** Names a conversation, on results across conversations. */
+    conversationTitle?: (conversationId: string) => string;
+    /** Start with the box focused. */
+    autoFocus?: boolean;
+    debounceMs?: number;
+    className?: string;
+}
+/** A snippet with its « » marks as <mark>. */
+declare function SearchSnippet({ snippet, className }: {
+    snippet: string;
+    className?: string;
+}): react.JSX.Element;
+declare function ChatSearch({ resolveUser, conversationId, onOpen, conversationTitle, autoFocus, debounceMs, className }: ChatSearchProps): react.JSX.Element;
+
+/**
+ * @feat:chat
+ * `ChatErrorBoundary`: what one message (or one app attachment card) draws can't take the whole
+ * thread down. Messages carry what other people sent, and app renderers get sender-controlled
+ * data, so a render that throws shows its fallback instead, and the error goes to `onError`
+ * (console.error by default) so it is never silent.
+ */
+
+interface ChatErrorBoundaryProps {
+    /** Drawn instead of the children once they throw. */
+    fallback: ReactNode;
+    /** Told about the error; console.error by default. */
+    onError?: (error: unknown, info: ErrorInfo) => void;
+    children: ReactNode;
+}
+declare class ChatErrorBoundary extends Component<ChatErrorBoundaryProps, {
+    failed: boolean;
+}> {
+    state: {
+        failed: boolean;
+    };
+    static getDerivedStateFromError(): {
+        failed: boolean;
+    };
+    componentDidCatch(error: unknown, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+
+/** The picker can load: an emojibase URL was given. */
+declare const canPickEmoji: (emojibaseUrl: string | null | undefined) => emojibaseUrl is string;
+interface ChatEmojiPickerProps {
+    onSelect: (emoji: string) => void;
+    /** Where the Emojibase data is fetched from (`${emojibaseUrl}/en/data.json`). Required to load anything. */
+    emojibaseUrl?: string;
+    locale?: "en";
+    columns?: number;
+    className?: string;
+}
+declare function ChatEmojiPicker({ onSelect, emojibaseUrl, locale, columns, className }: ChatEmojiPickerProps): react.JSX.Element;
+
+type VideoRecorderState = "idle" | "requesting" | "previewing" | "recording" | "recorded" | "denied" | "unsupported" | "error";
+interface VideoRecording {
+    blob: Blob;
+    /** Without codec parameters: `video/webm` or `video/mp4`. */
+    contentType: string;
+    name: string;
+    durationMs: number;
+    /** An object URL for playback before sending. */
+    url: string | null;
+}
+/** MP4 where the browser records it (Safari, recent Chrome), else WebM. */
+declare function pickVideoMimeType(): string | null;
+interface UseVideoRecorderOptions {
+    /** It stops itself here (`recordingLimitMs(role)`). */
+    maxMs: number;
+    /** About every second while recording (to tell the others). */
+    onTick?: () => void;
+}
+declare function useVideoRecorder({ maxMs, onTick }: UseVideoRecorderOptions): {
+    state: VideoRecorderState;
+    error: string | null;
+    elapsedMs: number;
+    maxMs: number;
+    stream: MediaStream | null;
+    recording: VideoRecording | null;
+    open: () => Promise<boolean>;
+    start: () => Promise<void>;
+    stop: () => void;
+    retake: () => Promise<void>;
+    reset: () => void;
+    handOff: () => void;
+};
+type VideoRecorder = ReturnType<typeof useVideoRecorder>;
+/**
+ * A recording as a file for the outbox: `hosted` sends it to the hosted provider (the provider's
+ * `videoUpload`, the message going at once with the video pending); otherwise it goes to storage.
+ */
+declare function videoFile(rec: VideoRecording, opts?: {
+    hosted?: boolean;
+}): LocalFile;
+/**
+ * Uploads a recording through the app's `videoUpload` (a Mux direct upload: PUT the bytes to
+ * the URL it returns) and gives back the attachment to send, pending until Mux's webhook marks
+ * it ready. The composer no longer uses it: it sends `videoFile(rec, { hosted: true })` through
+ * the outbox, so the message keeps its place in the order while the bytes go up.
+ */
+declare function uploadVideo(videoUpload: ChatVideoUpload, conversationId: string, rec: Pick<VideoRecording, "blob" | "contentType" | "durationMs" | "name">, fetchImpl?: typeof fetch, signal?: AbortSignal): Promise<AttachmentInput>;
+interface ChatVideoRecorderProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    conversationId: string;
+    maxMs: number;
+    /** From useConversation: sends through the outbox. */
+    send: (input: Omit<SendInput, "conversationId" | "clientId">, files?: LocalFile[]) => Promise<unknown>;
+    /** Merged into what's sent (a reply, a topic, an internal note). */
+    extra?: Omit<SendInput, "conversationId" | "clientId" | "attachments" | "body">;
+    /**
+     * Marks the take as hosted. Pass the same `videoUpload` the `ChatProvider` has (or give the
+     * provider a `hostedUpload`): the outbox does the upload, and without one it falls back to
+     * storage with no error.
+     */
+    videoUpload?: ChatVideoUpload;
+    onTick?: () => void;
+    onSent?: () => void;
+    /** @deprecated Unused: the bytes go through the outbox's `hostedUpload` now. */
+    fetchImpl?: typeof fetch;
+}
+/** The composer's video dialog: preview, record (to the role's limit), review, retake, send. */
+declare function ChatVideoRecorder({ open, onOpenChange, maxMs, send, extra, videoUpload, onTick, onSent }: ChatVideoRecorderProps): react.JSX.Element;
+declare const muxStreamUrl: (playbackId: string) => string;
+declare const muxPosterUrl: (playbackId: string) => string;
+interface ChatVideoPlayerProps {
+    /** A file URL (storage), when there is no playback id. */
+    src?: string | null;
+    /** Mux's playback id: streamed as HLS. */
+    playbackId?: string | null;
+    poster?: string | null;
+    /** Mux is still working on it. */
+    processing?: boolean;
+    failed?: boolean;
+    /** Still uploading from this device. */
+    uploading?: boolean;
+    label?: string;
+    className?: string;
+}
+/** Plays a chat video: Mux HLS (native, else hls.js loaded on demand), or a file. */
+declare function ChatVideoPlayer({ src, playbackId, poster, processing, failed, uploading, label, className }: ChatVideoPlayerProps): react.JSX.Element;
+
+export { type AttachmentView, ChatAttachmentCard, type ChatAttachmentCardProps, type ChatAttachmentSlotProps, ChatAvailabilitySettings, type ChatAvailabilitySettingsProps, ChatAwayBanner, type ChatAwayBannerProps, ChatBroadcast, type ChatBroadcastProps, ChatComposer, type ChatComposerAccessoryProps, type ChatComposerHandle, type ChatComposerProps, ChatEmojiPicker, type ChatEmojiPickerProps, ChatErrorBoundary, type ChatErrorBoundaryProps, ChatInbox, type ChatInboxEmptyProps, type ChatInboxProps, ChatLinkPreview, type ChatLinkPreviewProps, ChatMarkdown, type ChatMarkdownProps, ChatPanel, type ChatPanelNoSelectionProps, type ChatPanelProps, ChatScheduleMenu, type ChatScheduleMenuProps, ChatScheduledList, type ChatScheduledListProps, ChatSearch, type ChatSearchProps, ChatThread, type ChatThreadEmptyProps, type ChatThreadHeaderProps, type ChatThreadProps, type ChatThreadSlots, ChatTopicBar, type ChatTopicBarProps, type ChatUser, ChatVideoPlayer, type ChatVideoPlayerProps, ChatVideoRecorder, type ChatVideoRecorderProps, FileChip, GenericAttachment, ImageGrid, type ImageGridProps, Lightbox, type LightboxProps, type LinkPreviewImages, type MarkdownNode, type MemoryChatClient, type MemoryChatOptions, type MemoryConversationSeed, MessageAttachments, type MessageAttachmentsProps, MessageRow, type MessageRowProps, QUICK_REACTIONS, type ResolveUser, SearchSnippet, type UseVideoRecorderOptions, type UseVoiceRecorderOptions, VideoAttachment, type VideoRecorder, type VideoRecorderState, type VideoRecording, VoiceNote, type VoiceNoteProps, type VoiceRecorder, type VoiceRecorderState, type VoiceRecording, canPickEmoji, clockTime, createMemoryChatClient, formatBytes, inboxTitle, isSafeHref, linkPreviewImageSrc, messageLabel, muxPosterUrl, muxStreamUrl, parseMarkdown, pickVideoMimeType, pickVoiceMimeType, plainText, relativeTime, toAttachmentView, toLocalInput, uploadVideo, useVideoRecorder, useVoiceRecorder, videoFile, voiceFile };