@webority/mobile-chat 0.0.0-stage → 0.4.0

package/lib/typescript/commonjs/components/ChatMarkdown.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+export interface ChatMarkdownProps<T = string> {
+    /** The reply text, possibly still arriving. */
+    text: string;
+    /**
+     * Maps a reply link (`scheme:kind/id`, e.g. `app:requirement/R-12`) to what it opens in the
+     * app: a route, a screen and its params, anything `onLinkPress` understands. Return null for a
+     * link the app does not know; it then shows as plain text. A web address never reaches it.
+     */
+    resolveLink?: (href: string) => T | null | undefined;
+    /** Opens what `resolveLink` returned. Without it, links show as plain text. */
+    onLinkPress?: (target: T) => void;
+    testID?: string;
+}
+/**
+ * Renders a reply from a small, safe subset of Markdown: paragraphs, bold, italics, inline code,
+ * bullet and numbered lists, simple tables (scrolling sideways), headings (as bold lines), code
+ * blocks and rules. It never opens a web address: a link shows only when its href has the form
+ * `scheme:kind/id` and `resolveLink` maps it. Text still arriving updates the last block in place,
+ * and an unclosed `**` shows as typed until its partner arrives.
+ */
+export declare function ChatMarkdown<T = string>({ text, resolveLink, onLinkPress, testID }: ChatMarkdownProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatMarkdown.d.ts.map

package/lib/typescript/commonjs/components/ChatMessage.d.ts

@@ -0,0 +1,35 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels';
+import type { ChatRating, SupportActionTicket } from '../types';
+import type { ChatTurn } from '../useChat';
+/** The props a thread passes to each of its turns. */
+export interface ChatReplyProps<T = string> {
+    /** Shows the rating under a stored reply. */
+    onRate?: (turnId: string, rating: ChatRating, note?: string) => Promise<unknown>;
+    /** Maps a reply link to what it opens; see `ChatMarkdown`. */
+    resolveLink?: (href: string) => T | null | undefined;
+    /** Opens what `resolveLink` returned. */
+    onLinkPress?: (target: T) => void;
+    /** Shows support action cards; see `ActionCard`. */
+    confirmAction?: (token: string) => Promise<SupportActionTicket>;
+    onViewTicket?: (ticket: SupportActionTicket) => void;
+    /**
+     * Draws the assistant's answer in place of `ChatMarkdown` (charts, maths). The question, action
+     * cards, rating and layout stay the library's.
+     */
+    renderReply?: (turn: ChatTurn, state: {
+        streaming: boolean;
+    }) => React.ReactNode;
+    labels?: Partial<ChatLabels>;
+}
+export interface ChatMessageProps<T = string> extends ChatReplyProps<T> {
+    turn: ChatTurn;
+    testID?: string;
+}
+/**
+ * One turn: the person's question on the right, the assistant's answer on the left. The answer is
+ * a polite live region, so a screen reader reads it as it settles. Support actions show under the
+ * answer, and the rating once the reply is stored.
+ */
+export declare function ChatMessage<T = string>({ turn, onRate, resolveLink, onLinkPress, confirmAction, onViewTicket, renderReply, labels: labelOverrides, testID }: ChatMessageProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatMessage.d.ts.map

package/lib/typescript/commonjs/components/ChatScreen.d.ts

@@ -0,0 +1,30 @@
+import type React from 'react';
+import type { UseChatResult } from '../useChat';
+import type { ChatReplyProps } from './ChatMessage';
+export interface ChatScreenProps<T = string> extends Omit<ChatReplyProps<T>, 'onRate'> {
+    /** The `useChat` result. */
+    chat: UseChatResult;
+    /** Header title. Defaults to the `panelTitle` label. */
+    title?: string;
+    /** Extra header controls before New chat, e.g. an "All chats" button. */
+    headerActions?: React.ReactNode;
+    /** Shown before the first question, in place of the default title and text. */
+    empty?: React.ReactNode;
+    /** The footnote under the question box. Defaults to the `disclaimer` label; null hides it. */
+    disclaimer?: string | null;
+    /** The server's message limit. Default 4000. */
+    maxLength?: number;
+    /** Show the questions left once this many or fewer remain. Default 10. */
+    allowanceThreshold?: number;
+    /** Offer ratings under stored replies. Default true. */
+    rating?: boolean;
+    testID?: string;
+}
+/**
+ * The whole chat for one screen of the app's navigator: a header with New chat, the
+ * conversation, the questions left today, the question box and the AI disclaimer. The question
+ * box rises with the keyboard. Place it in a stack screen (or a full-height sheet) and keep the
+ * `useChat` call above the navigator, so the conversation survives leaving the screen.
+ */
+export declare function ChatScreen<T = string>({ chat, title, headerActions, empty, disclaimer, maxLength, allowanceThreshold, rating, testID, ...reply }: ChatScreenProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatScreen.d.ts.map

package/lib/typescript/commonjs/components/ChatThread.d.ts

@@ -0,0 +1,17 @@
+import type React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { ChatTurn } from '../useChat';
+import { type ChatReplyProps } from './ChatMessage';
+export interface ChatThreadProps<T = string> extends ChatReplyProps<T> {
+    turns: ChatTurn[];
+    /** Shown before the first question. */
+    empty?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * The conversation, oldest first, in a scroll view that follows the newest text while an answer
+ * streams and when a question is added.
+ */
+export declare function ChatThread<T = string>({ turns, empty, style, testID, ...reply }: ChatThreadProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatThread.d.ts.map

package/lib/typescript/commonjs/components/ReplyRating.d.ts

@@ -0,0 +1,19 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels';
+import type { ChatRating } from '../types';
+export interface ReplyRatingProps {
+    /** The rating already saved. */
+    rating?: ChatRating | null;
+    /** Saves a rating; rejects on failure. */
+    onRate: (rating: ChatRating, note?: string) => Promise<unknown>;
+    /** The server's note limit. Default 1000. */
+    noteMaxLength?: number;
+    labels?: Partial<ChatLabels>;
+    testID?: string;
+}
+/**
+ * Helpful and Not helpful under one reply. Either saves at once; Not helpful then offers an
+ * optional note, saved with the same rating. Either choice can be changed.
+ */
+export declare const ReplyRating: React.FC<ReplyRatingProps>;
+//# sourceMappingURL=ReplyRating.d.ts.map

package/lib/typescript/commonjs/index.d.ts

@@ -0,0 +1,28 @@
+export type { ChatClient, ChatHttpClient, ChatHttpRequestConfig } from './client';
+export { ChatApiError, createChatClient } from './client';
+export type { ActionCardProps } from './components/ActionCard';
+export { ActionCard } from './components/ActionCard';
+export type { ChatComposerProps } from './components/ChatComposer';
+export { ChatComposer } from './components/ChatComposer';
+export type { ChatConversationListProps } from './components/ChatConversationList';
+export { ChatConversationList } from './components/ChatConversationList';
+export type { ChatLauncherProps } from './components/ChatLauncher';
+export { ChatLauncher } from './components/ChatLauncher';
+export type { ChatMarkdownProps } from './components/ChatMarkdown';
+export { ChatMarkdown } from './components/ChatMarkdown';
+export type { ChatMessageProps, ChatReplyProps } from './components/ChatMessage';
+export { ChatMessage } from './components/ChatMessage';
+export type { ChatScreenProps } from './components/ChatScreen';
+export { ChatScreen } from './components/ChatScreen';
+export type { ChatThreadProps } from './components/ChatThread';
+export { ChatThread } from './components/ChatThread';
+export type { ReplyRatingProps } from './components/ReplyRating';
+export { ReplyRating } from './components/ReplyRating';
+export type { ChatLabels } from './labels';
+export { DEFAULT_CHAT_LABELS } from './labels';
+export type { SseEvent, SseParser } from './sse';
+export { createSseParser } from './sse';
+export type { ChatRating, ChatRatingInput, ChatStreamEventName, ChatStreamOptions, ChatTurnInput, ChatTurnResult, Conversation, ConversationMessage, ConversationSummary, SupportAction, SupportActionTicket } from './types';
+export type { ChatTurn, ChatTurnError, UseChatOptions, UseChatResult } from './useChat';
+export { useChat } from './useChat';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/commonjs/labels.d.ts

@@ -0,0 +1,63 @@
+export interface ChatLabels {
+    launcher: string;
+    panelTitle: string;
+    newChat: string;
+    close: string;
+    thread: string;
+    you: string;
+    assistant: string;
+    thinking: string;
+    emptyTitle: string;
+    emptyText: string;
+    composer: string;
+    placeholder: string;
+    send: string;
+    composerHint: string;
+    allowance: (count: number) => string;
+    disclaimer: string;
+    loadingConversation: string;
+    rateUp: string;
+    rateDown: string;
+    rated: string;
+    ratingNote: string;
+    ratingNoteHint: string;
+    ratingNoteSend: string;
+    ratingNoteSkip: string;
+    ratingFailed: string;
+    actionRaiseTicket: string;
+    actionReply: (ticketNumber: string) => string;
+    actionReopen: (ticketNumber: string) => string;
+    actionNote: string;
+    actionConfirm: string;
+    actionDismiss: string;
+    actionDismissed: string;
+    actionExpired: string;
+    actionFailed: string;
+    actionDoneRaiseTicket: (ticketNumber: string) => string;
+    actionDoneReply: (ticketNumber: string) => string;
+    actionDoneReopen: (ticketNumber: string) => string;
+    viewTicket: string;
+    conversations: string;
+    conversationsEmptyTitle: string;
+    conversationsEmptyText: string;
+    untitled: string;
+    deleteConversation: string;
+    deleteConfirmTitle: string;
+    deleteConfirmMessage: string;
+    deleteConfirm: string;
+    deleteFailed: string;
+    cancel: string;
+    loadMore: string;
+    loadFailed: string;
+    retry: string;
+}
+/**
+ * Every word the chat components show, in English, with the same keys as the web assistant's
+ * labels, so a product passes one label set to both. Pass a `labels` object with any subset to a
+ * component to change its wording; the rest keep these defaults. The few that take a value are
+ * functions. `composerHint` describes a hardware keyboard's Enter key and is not shown on a phone.
+ */
+export declare const DEFAULT_CHAT_LABELS: Readonly<ChatLabels>;
+/** The defaults with a component's `labels` laid over them. */
+export declare const mergeLabels: (labels?: Partial<ChatLabels>) => ChatLabels;
+//# sourceMappingURL=labels.d.ts.map

package/lib/typescript/commonjs/markdownParse.d.ts

@@ -0,0 +1,59 @@
+type BlockShape = {
+    type: 'paragraph';
+    lines: string[];
+} | {
+    type: 'heading';
+    text: string;
+} | {
+    type: 'list';
+    ordered: boolean;
+    start: number;
+    items: string[];
+} | {
+    type: 'table';
+    header: string[];
+    rows: string[][];
+} | {
+    type: 'code';
+    text: string;
+} | {
+    type: 'rule';
+};
+export type MarkdownBlock = BlockShape & {
+    key: number;
+};
+type InlineShape = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'code';
+    text: string;
+} | {
+    type: 'strong' | 'em';
+    children: InlineToken[];
+} | {
+    type: 'link';
+    href: string;
+    children: InlineToken[];
+};
+export type InlineToken = InlineShape & {
+    key: number;
+};
+/**
+ * Splits reply text into blocks: paragraphs, headings, bullet and numbered lists, simple tables,
+ * code blocks and rules. Each block's `key` is its position, so text arriving at the end of a
+ * streaming reply updates the last block in place and never remounts the ones before it.
+ */
+export declare const parseBlocks: (text: string | null | undefined) => MarkdownBlock[];
+/**
+ * Reads bold (`**` or `__`), italics (`*` or `_`), inline code and `[label](href)` links. A marker
+ * with no partner yet (a reply still streaming) shows as the characters typed.
+ */
+export declare const parseInline: (text: string) => InlineToken[];
+/**
+ * What a reply link opens, or null when it may not open anything. Only `scheme:kind/id` hrefs
+ * reach `resolveLink`; a web address never does, so a reply cannot send the person off the app.
+ */
+export declare const linkTarget: <T>(href: string, resolveLink: ((href: string) => T | null | undefined) | undefined) => T | null;
+export {};
+//# sourceMappingURL=markdownParse.d.ts.map

package/lib/typescript/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/typescript/commonjs/sse.d.ts

@@ -0,0 +1,23 @@
+export interface SseEvent {
+    /** The `event:` field, or "message" when the block names none. */
+    name: string;
+    /** The `data:` lines joined by newlines and parsed as JSON. */
+    data: unknown;
+}
+export interface SseParser {
+    push: (text: string) => void;
+    end: () => void;
+}
+/**
+ * An incremental reader for a `text/event-stream` body that arrives in pieces. Each `push` takes
+ * the next piece of text; only complete events (ended by a blank line) are handed on, and the
+ * incomplete tail waits for the next piece. `end` flushes a final event the stream closed
+ * without a blank line after.
+ *
+ * Line endings may be `\n`, `\r\n` or `\r`, and a `\r\n` pair may be split across two pieces.
+ * Comment lines (`:`), `id` and `retry` are ignored. A block whose data is not JSON is reported
+ * as an `error` event with the code `invalid-response`, so a caller ends the turn instead of
+ * hanging on it.
+ */
+export declare const createSseParser: (onEvent: (event: SseEvent) => void) => SseParser;
+//# sourceMappingURL=sse.d.ts.map

package/lib/typescript/commonjs/types.d.ts

@@ -0,0 +1,71 @@
+/** An action the assistant prepared for the person to confirm. Nothing happens without the token. */
+export interface SupportAction {
+    token: string;
+    kind: 'RaiseTicket' | 'Reply' | 'Reopen';
+    ticketId: string | null;
+    ticketNumber: string | null;
+    category: string | null;
+    subject: string | null;
+    body: string | null;
+    expiresDateTimeUtc: string;
+}
+/** The ticket a confirmed support action raised, replied on or reopened. */
+export interface SupportActionTicket {
+    id: string;
+    number: string;
+}
+export interface ChatTurnInput {
+    /** The person's question. */
+    message: string;
+    /** The conversation to continue; left out or null to start one. */
+    conversationId?: string | null;
+    /** Product-defined context about the screen, passed through as is. */
+    pageContext?: unknown;
+}
+export type ChatStreamEventName = 'delta' | 'reset' | 'actions';
+export interface ChatStreamOptions {
+    /** Cancels the request. */
+    signal?: AbortSignal;
+    /**
+     * Called for each event before the end of the turn: `delta { text }` to append, `reset {}` to
+     * discard what was shown, `actions { actions }` for support cards.
+     */
+    onEvent?: (name: ChatStreamEventName, data: unknown) => void;
+}
+/** The `done` event: the turn's outcome of record. */
+export interface ChatTurnResult {
+    conversationId: string;
+    /** The stored reply's id, for rating; null when storing failed. */
+    messageId: string | null;
+    /** The reply of record. It replaces whatever was streamed. */
+    reply: string;
+    /** Null when the person has no daily limit. */
+    messagesLeftToday: number | null;
+}
+export interface ConversationSummary {
+    publicId: string;
+    title: string | null;
+    createdDateTimeUtc: string;
+    lastMessageDateTimeUtc: string;
+}
+export interface ConversationMessage {
+    publicId: string;
+    role: 'User' | 'Assistant';
+    content: string;
+    /** The support actions offered with an assistant reply, as a JSON array. */
+    actionsJson: string | null;
+    rating: ChatRating | null;
+    ratingNote: string | null;
+    createdDateTimeUtc: string;
+}
+export interface Conversation {
+    publicId: string;
+    title: string | null;
+    messages: ConversationMessage[];
+}
+export type ChatRating = 'Up' | 'Down';
+export interface ChatRatingInput {
+    rating: ChatRating;
+    note?: string | null;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/commonjs/useChat.d.ts

@@ -0,0 +1,63 @@
+import type { ChatClient } from './client';
+import type { ChatRating, SupportAction } from './types';
+export interface ChatTurnError {
+    code: string;
+    /** Written for the person. */
+    message: string;
+    resetsAtUtc: string | null;
+}
+/** One question and its answer. */
+export interface ChatTurn {
+    /** Local key; for a reopened conversation, the stored message's id. */
+    id: string;
+    question: string;
+    /** What is shown: the streamed text, then the reply of record. */
+    answer: string;
+    streaming: boolean;
+    error: ChatTurnError | null;
+    actions: SupportAction[];
+    /** The stored reply's id; rating needs it. */
+    messageId: string | null;
+    rating: ChatRating | null;
+    ratingNote: string | null;
+}
+export interface UseChatOptions {
+    /** From `createChatClient`. */
+    client: ChatClient;
+    /** Sent with each question; read at the moment of sending. */
+    pageContext?: unknown;
+}
+export interface UseChatResult {
+    /** Oldest first. */
+    turns: ChatTurn[];
+    /** The conversation being continued, or null. */
+    conversationId: string | null;
+    /** From the last answer or `refreshAllowance()`; null with no daily limit. */
+    messagesLeftToday: number | null;
+    /** An answer is arriving. */
+    streaming: boolean;
+    /** `openConversation` is loading. */
+    loading: boolean;
+    /** `openConversation` failed. */
+    loadError: ChatTurnError | null;
+    /** Asks a question. Ignored while an answer is still arriving. */
+    submit: (message: string) => Promise<void>;
+    /** Replaces the thread with a stored conversation. */
+    openConversation: (id: string) => Promise<void>;
+    /** Clears the thread; the next question starts a conversation. */
+    newConversation: () => void;
+    /** Saves a rating, shown at once; a failed save puts the old one back and rejects. */
+    rate: (turnId: string, rating: ChatRating, note?: string) => Promise<void>;
+    /** Reads the questions left today. */
+    refreshAllowance: () => Promise<void>;
+    /** Clears everything, for sign-out or an account switch. */
+    reset: () => void;
+}
+/**
+ * The chat's state and actions, with no store of its own: it lives in the component that calls
+ * it. Call `reset()` when the signed-in person or account changes so nothing of one person's chat
+ * shows to the next. An answer still streaming is cancelled on `reset`, `newConversation`,
+ * `openConversation` and unmount.
+ */
+export declare const useChat: ({ client, pageContext }: UseChatOptions) => UseChatResult;
+//# sourceMappingURL=useChat.d.ts.map

package/lib/typescript/module/client.d.ts

@@ -0,0 +1,73 @@
+import type { ChatRatingInput, ChatStreamOptions, ChatTurnInput, ChatTurnResult, Conversation, ConversationSummary } from './types.js';
+/** A failed chat request. `message` is written for the person and is safe to show as is. */
+export declare class ChatApiError extends Error {
+    /**
+     * The server's code (`daily-limit`, `assistant-unavailable`, ...), `network` when no response
+     * arrived, `aborted` when the request was cancelled, `invalid-response`, or `unknown`.
+     */
+    readonly code: string;
+    /** The HTTP status, when a response arrived. */
+    readonly status: number | undefined;
+    /** For `daily-limit`: when the allowance comes back, in UTC. */
+    readonly resetsAtUtc: string | null;
+    constructor(code: string, message: string, status?: number, resetsAtUtc?: string | null);
+}
+/** The axios config fields the chat client sets. */
+export interface ChatHttpRequestConfig {
+    headers?: Record<string, string>;
+    responseType?: 'text';
+    signal?: AbortSignal;
+    onDownloadProgress?: (progress: unknown) => void;
+}
+/**
+ * The slice of an HTTP client the chat client needs. The app's signed-in axios instance
+ * (mobile-core's `userClient`, or its own) satisfies it as is, so the bearer token, tenant header
+ * and refresh on 401 apply to chat calls too. Declared structurally so no axios type leaks into
+ * this package's declarations.
+ */
+export interface ChatHttpClient {
+    get(url: string, config?: ChatHttpRequestConfig): Promise<{
+        data: unknown;
+    }>;
+    post(url: string, body?: unknown, config?: ChatHttpRequestConfig): Promise<{
+        data: unknown;
+        status?: number;
+    }>;
+    put(url: string, body?: unknown, config?: ChatHttpRequestConfig): Promise<{
+        data: unknown;
+    }>;
+    delete(url: string, config?: ChatHttpRequestConfig): Promise<{
+        data: unknown;
+    }>;
+}
+export interface ChatClient {
+    /** `POST {base}/chat`, streamed; resolves with the `done` event. */
+    sendMessage(input: ChatTurnInput, options?: ChatStreamOptions): Promise<ChatTurnResult>;
+    /** `GET {base}/allowance`. */
+    getAllowance(): Promise<{
+        messagesLeftToday: number | null;
+    }>;
+    /** `GET {base}/conversations?skip=&take=`, newest first. */
+    listConversations(query?: {
+        skip?: number;
+        take?: number;
+    }): Promise<ConversationSummary[]>;
+    /** `GET {base}/conversations/{id}`. */
+    getConversation(id: string): Promise<Conversation>;
+    /** `DELETE {base}/conversations/{id}`. */
+    deleteConversation(id: string): Promise<void>;
+    /** `PUT {base}/conversations/{conversationId}/messages/{messageId}/rating`. */
+    rateMessage(conversationId: string, messageId: string, input: ChatRatingInput): Promise<void>;
+}
+/**
+ * Binds the chat HTTP contract to the app's own signed-in axios instance. The package never
+ * handles auth: tokens, tenant headers and refresh stay in the instance.
+ *
+ * @param http The app's axios instance, e.g. mobile-core's `userClient`.
+ * @param options `base` is the prefix the API maps the chat endpoints under, e.g.
+ *   `/api/assistant` for `POST /api/assistant/chat`.
+ */
+export declare const createChatClient: (http: ChatHttpClient, { base }: {
+    base: string;
+}) => ChatClient;
+//# sourceMappingURL=client.d.ts.map

package/lib/typescript/module/components/ActionCard.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels.js';
+import type { SupportAction, SupportActionTicket } from '../types.js';
+export interface ActionCardProps {
+    action: SupportAction;
+    /**
+     * Sends the person's yes, e.g. mobile-support's `supportClient.confirmAction`; resolves to the
+     * ticket raised, replied on or reopened. A rejection's `message` is shown when present.
+     */
+    confirmAction: (token: string) => Promise<SupportActionTicket>;
+    /** Shows a View ticket button once confirmed. */
+    onViewTicket?: (ticket: SupportActionTicket) => void;
+    labels?: Partial<ChatLabels>;
+    testID?: string;
+}
+/**
+ * One support action the assistant prepared, shown under its reply. Nothing reaches support until
+ * the person confirms. The card moves from ready to sending to done (with View ticket), or to
+ * dismissed on Not now. An expired action (a reopened conversation) still shows what was offered,
+ * without a button that could only fail.
+ */
+export declare const ActionCard: React.FC<ActionCardProps>;
+//# sourceMappingURL=ActionCard.d.ts.map

package/lib/typescript/module/components/ChatComposer.d.ts

@@ -0,0 +1,20 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels.js';
+export interface ChatComposerProps {
+    /** Called with the trimmed question; the box clears once it is handed over. */
+    onSubmit: (message: string) => unknown;
+    /** An answer is arriving: the question can be typed but not sent. */
+    busy?: boolean;
+    /** No question can be asked, e.g. none left today. */
+    disabled?: boolean;
+    /** The server's message limit. Default 4000. */
+    maxLength?: number;
+    labels?: Partial<ChatLabels>;
+    testID?: string;
+}
+/**
+ * The question box and its send button. The return key adds a new line, as phone keyboards
+ * expect; only the button sends.
+ */
+export declare const ChatComposer: React.FC<ChatComposerProps>;
+//# sourceMappingURL=ChatComposer.d.ts.map

package/lib/typescript/module/components/ChatConversationList.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { ChatClient } from '../client.js';
+import { type ChatLabels } from '../labels.js';
+import type { ConversationSummary } from '../types.js';
+export interface ChatConversationListProps {
+    client: ChatClient;
+    /** E.g. go to the chat and call `chat.openConversation(conversation.publicId)`. */
+    onOpen: (conversation: ConversationSummary) => void;
+    /** Called after a chat is deleted, e.g. to start a new chat when the open one was deleted. */
+    onDeleted?: (id: string) => void;
+    /** Default 20. */
+    pageSize?: number;
+    labels?: Partial<ChatLabels>;
+    style?: StyleProp<ViewStyle>;
+    testID?: string;
+}
+/**
+ * The person's past chats, newest first. It pages with Show more, refreshes on pull, opens one
+ * through `onOpen`, and deletes one after a confirm.
+ */
+export declare const ChatConversationList: React.FC<ChatConversationListProps>;
+//# sourceMappingURL=ChatConversationList.d.ts.map

package/lib/typescript/module/components/ChatLauncher.d.ts

@@ -0,0 +1,22 @@
+import type React from 'react';
+import { type ChatLabels } from '../labels.js';
+export interface ChatLauncherProps {
+    onPress: () => void;
+    /** `end` (the default) or `start`: the bottom corner it sits in. */
+    position?: 'end' | 'start';
+    /**
+     * Distance above the bottom safe area, so it clears a tab bar or another floating control.
+     * Defaults to the theme's floating action button offset.
+     */
+    bottomOffset?: number;
+    /** Show only the icon, with the label as its accessible name. */
+    compact?: boolean;
+    labels?: Partial<ChatLabels>;
+    testID?: string;
+}
+/**
+ * An optional floating button that opens the chat. A phone app usually opens the chat from a
+ * header action or a Help row instead; use this where a floating entry point fits the screen.
+ */
+export declare const ChatLauncher: React.FC<ChatLauncherProps>;
+//# sourceMappingURL=ChatLauncher.d.ts.map

package/lib/typescript/module/components/ChatMarkdown.d.ts

@@ -0,0 +1,23 @@
+import type React from 'react';
+export interface ChatMarkdownProps<T = string> {
+    /** The reply text, possibly still arriving. */
+    text: string;
+    /**
+     * Maps a reply link (`scheme:kind/id`, e.g. `app:requirement/R-12`) to what it opens in the
+     * app: a route, a screen and its params, anything `onLinkPress` understands. Return null for a
+     * link the app does not know; it then shows as plain text. A web address never reaches it.
+     */
+    resolveLink?: (href: string) => T | null | undefined;
+    /** Opens what `resolveLink` returned. Without it, links show as plain text. */
+    onLinkPress?: (target: T) => void;
+    testID?: string;
+}
+/**
+ * Renders a reply from a small, safe subset of Markdown: paragraphs, bold, italics, inline code,
+ * bullet and numbered lists, simple tables (scrolling sideways), headings (as bold lines), code
+ * blocks and rules. It never opens a web address: a link shows only when its href has the form
+ * `scheme:kind/id` and `resolveLink` maps it. Text still arriving updates the last block in place,
+ * and an unclosed `**` shows as typed until its partner arrives.
+ */
+export declare function ChatMarkdown<T = string>({ text, resolveLink, onLinkPress, testID }: ChatMarkdownProps<T>): React.ReactElement;
+//# sourceMappingURL=ChatMarkdown.d.ts.map