inline-chat-kit 0.49.0

package/dist/AnswerActions/AnswerActions.d.ts

@@ -0,0 +1,35 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export type Verdict = "up" | "down";
+export interface AnswerActionsProps extends Omit<HTMLAttributes<HTMLDivElement>, "onCopy"> {
+    /** The answer these act on. Copy takes it; the callbacks receive it. */
+    text: string;
+    /** Defaults to the clipboard. */
+    onCopy?: (text: string) => void;
+    /** Omit and no regenerate button is drawn. */
+    onRegenerate?: () => void;
+    /**
+     * Omit and no thumbs are drawn. Called with `null` when a verdict is taken
+     * back — pressing the one already given is how somebody undoes it.
+     */
+    onFeedback?: (verdict: Verdict | null) => void;
+    /** Controlled, for a host that stores the verdict. */
+    feedback?: Verdict | null;
+    /** Anything else, after the built-in controls. */
+    children?: ReactNode;
+    /**
+     * Invisible until hovered or focused. It still occupies its space and still
+     * hit-tests, so nothing shifts and nothing is unreachable — `:focus-within`
+     * brings it back for anyone arriving by keyboard.
+     */
+    reveal?: boolean;
+    /** While an answer is being regenerated. */
+    busy?: boolean;
+    labels?: Partial<Record<"copy" | "copied" | "regenerate" | "up" | "down", string>>;
+}
+/**
+ * What you can do to an answer once it has arrived.
+ *
+ * The input has had a hover row since the beginning; the answer had nothing,
+ * which is backwards — the answer is the part worth keeping.
+ */
+export declare function AnswerActions({ text, onCopy, onRegenerate, onFeedback, feedback, children, reveal, busy, labels, className, ...rest }: AnswerActionsProps): import("react").JSX.Element;

package/dist/Approval/Approval.d.ts

@@ -0,0 +1,42 @@
+import { HTMLAttributes, ReactNode } from 'react';
+/** Once, every time from now on, or not at all. */
+export type Decision = "once" | "always" | "denied";
+type Labels = Record<"once" | "always" | "deny", string> & Record<"allowedOnce" | "allowedAlways" | "wasDenied" | "pending", string>;
+export interface ApprovalProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    /** What is being asked. One line: "Run a command in your shell". */
+    title: ReactNode;
+    /** Why it is being asked, or what it will touch. */
+    description?: ReactNode;
+    /**
+     * The thing itself — usually a `<Tool>` or a `<CodeBlock>`.
+     *
+     * Somebody deciding needs to see what they are deciding about, and a name is
+     * not that. An approval with nothing under it is asking for a signature on a
+     * blank page.
+     */
+    children?: ReactNode;
+    /** `null` while it is still being asked. */
+    decision?: Decision | null;
+    onDecide?: (decision: Decision) => void;
+    /** Nothing can be decided from here — a record of a decision already made. */
+    readOnly?: boolean;
+    labels?: Partial<Labels>;
+}
+/**
+ * "It wants to do this. Is that all right?"
+ *
+ * The one pattern from a coding agent that generalises to any agent that acts,
+ * and the only component in this kit whose whole job is to slow somebody down
+ * for a moment.
+ *
+ * Three decisions rather than two, because "yes" and "yes forever" are not the
+ * same answer and a UI offering one button for both collects the wrong one.
+ * **Allow once is the primary**: the narrow permission is the one that should
+ * be easiest to give, and the standing one should cost a moment's thought.
+ *
+ * Decided, it stops being a set of buttons and becomes a record of what was
+ * decided. Leaving live controls under a decision already made invites a
+ * second, contradictory one.
+ */
+export declare function Approval({ title, description, children, decision, onDecide, readOnly, labels, className, ...rest }: ApprovalProps): import("react").JSX.Element;
+export {};

package/dist/Artifact/ArtifactCard.d.ts

@@ -0,0 +1,45 @@
+import { HTMLAttributes, ReactNode } from 'react';
+/**
+ * Code, or everything else.
+ *
+ * Two, because they are drawn differently and nothing else is: code goes
+ * through the highlighter, prose keeps its line breaks and does not. An
+ * `image` kind can be added the day something needs one — it is a third
+ * preview, not a third idea.
+ */
+export type ArtifactKind = "code" | "text";
+/** Being written, or written. A file does not fail the way a call does. */
+export type ArtifactState = "writing" | "done";
+export interface ArtifactCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "title" | "content" | "onSelect"> {
+    /** What the pane opens. The card and the pane share nothing else. */
+    id: string;
+    title: ReactNode;
+    /** What it is, in a word or two — "Training plan", "12 lines of Python". */
+    meta?: ReactNode;
+    kind?: ArtifactKind;
+    /** The fence's language, for `kind="code"`. */
+    lang?: string;
+    /** What was written. Absent while it is still being written. */
+    content?: string;
+    state?: ArtifactState;
+    /**
+     * How much of it the card shows before the cut.
+     *
+     * The whole point of an artifact is that it is bigger than the answer, so
+     * the card is a window rather than the thing. Poured out in full it is not
+     * an artifact, it is a long message.
+     */
+    lines?: number;
+    /** Open it. Without one the card is a record rather than a control. */
+    onOpen?: (id: string) => void;
+    /** True while its pane is the one on screen. */
+    open?: boolean;
+}
+/**
+ * What the answer produced, in the transcript.
+ *
+ * A window onto it and a way in — not the thing itself. Press it and the pane
+ * beside the conversation shows the whole of it; the card stays where it is,
+ * because it is the line of the transcript that says the artifact was made.
+ */
+export declare function ArtifactCard({ id, title, meta, kind, lang, content, state, lines, onOpen, open, className, ...rest }: ArtifactCardProps): import("react").JSX.Element;

package/dist/Artifact/ArtifactPane.d.ts

@@ -0,0 +1,50 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export interface ArtifactPaneProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    title: ReactNode;
+    /** What it is, under the title. */
+    meta?: ReactNode;
+    /**
+     * What the host renders. Absent, the pane shows its own skeleton — an
+     * artifact usually arrives before it is finished, and a pane that opens
+     * empty reads as broken rather than as early.
+     */
+    children?: ReactNode;
+    onClose?: () => void;
+    /**
+     * The one prop that changes behaviour, and it is not about position.
+     *
+     * Below the layout's breakpoint the pane covers the conversation instead of
+     * standing beside it, and covering changes what it *is*: focus has to be
+     * held inside it and Escape has to close it, because there is nothing usable
+     * behind it. Beside the conversation both would be wrong — trapping focus
+     * would lock a reader out of the chat they are still reading.
+     *
+     * `<ChatLayout>` sets it from its own width. Set it yourself only if you are
+     * placing the pane without one.
+     */
+    modal?: boolean;
+    /**
+     * Widened. The pane draws the control; `ChatLayout` owns the width, because
+     * how much room the pane takes is a fact about the layout.
+     */
+    expanded?: boolean;
+    onToggleExpanded?: () => void;
+    closeLabel?: string;
+    expandLabel?: string;
+    collapseLabel?: string;
+}
+/**
+ * What the answer produced, in full, beside the conversation.
+ *
+ * The kit decides that it is on the right and that the conversation makes room
+ * for it — this is a pattern rather than a slot, and a chat where the pane
+ * arrives somewhere different each time is a chat nobody learns. What the kit
+ * does **not** decide is the content: a plan, a document, a table, a diagram.
+ * That is the host's, and it is why this takes children.
+ *
+ * The part worth having in a library is not the box. It is what happens on
+ * open: focus has to move here or a keyboard reader is left behind in the
+ * conversation, and it must **not** be trapped unless the pane is covering
+ * that conversation. Every host gets one of those two wrong.
+ */
+export declare function ArtifactPane({ title, meta, children, onClose, modal, expanded, onToggleExpanded, closeLabel, expandLabel, collapseLabel, className, ...rest }: ArtifactPaneProps): import("react").JSX.Element;

package/dist/Artifact/ChatLayout.d.ts

@@ -0,0 +1,35 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export interface PaneState {
+    /** The pane is covering the conversation rather than standing beside it. */
+    narrow: boolean;
+    /** It has been widened. Meaningless while `narrow`, which is already full. */
+    expanded: boolean;
+    toggleExpanded: () => void;
+}
+export interface ChatLayoutProps extends HTMLAttributes<HTMLDivElement> {
+    /** The conversation, and whatever else belongs above and below it. */
+    children: ReactNode;
+    /**
+     * The pane, when one is open.
+     *
+     * Given `narrow`, so it can hold focus and answer Escape once it is covering
+     * the conversation rather than standing beside it — the one thing about a
+     * pane that is not a matter of taste. And given `expanded` with the control
+     * for it, because the *width* belongs to the layout while the button that
+     * changes it belongs in the pane's own header, where somebody can find it.
+     */
+    pane?: (state: PaneState) => ReactNode;
+}
+/**
+ * Where the pane goes, decided once.
+ *
+ * The kit takes this decision rather than handing over a slot. A preview pane
+ * is one of the few patterns every AI chat now has, and the value of a pattern
+ * is that it is the same every time: ask for a plan, get a card, press it, the
+ * plan opens on the right. A kit that let each host place it would be shipping
+ * four chats that behave differently and calling it flexibility.
+ *
+ * What is left open is the part that actually differs — what is *in* the pane.
+ * See `ArtifactPane`.
+ */
+export declare function ChatLayout({ children, pane, className, ...rest }: ChatLayoutProps): import("react").JSX.Element;

package/dist/Artifact/useArtifacts.d.ts

@@ -0,0 +1,21 @@
+export interface Artifacts {
+    /** The one on screen, or `null`. */
+    openId: string | null;
+    open: (id: string) => void;
+    close: () => void;
+    /** Press the card that is already open and it closes, which is what a reader expects. */
+    toggle: (id: string) => void;
+}
+/**
+ * Which artifact is open.
+ *
+ * A hook rather than state inside the pane, for the reason `useChatTurns` is a
+ * hook: the card in the transcript and the pane beside it are in different
+ * parts of the tree and both need the answer. A pane that owned it could not
+ * tell a card it was the open one, and a card that owned it could not be told
+ * the pane had closed.
+ *
+ * One at a time. A stack of open artifacts is a tab bar, and a tab bar is a
+ * product's decision about how many things somebody is holding at once.
+ */
+export declare function useArtifacts(initial?: string | null): Artifacts;

package/dist/Attachments/Attachments.d.ts

@@ -0,0 +1,50 @@
+import { HTMLAttributes } from 'react';
+/** Something sent along with a message. */
+export interface Attachment {
+    id: string;
+    /** The filename, shown when there is no picture to show instead. */
+    name: string;
+    /**
+     * What to draw for it. An object URL, a data URL, or a remote one.
+     *
+     * Only used when `type` is an image. Anything else gets its name and a
+     * glyph, because a thumbnail of a PDF at 64px is a grey rectangle.
+     */
+    url?: string;
+    /** The MIME type. Decides between a picture and a name. */
+    type?: string;
+    /** In bytes. Shown beside the name. */
+    size?: number;
+}
+type Labels = {
+    remove: string;
+};
+export interface AttachmentsProps extends Omit<HTMLAttributes<HTMLUListElement>, "onRemove"> {
+    attachments: Attachment[];
+    /**
+     * Leave it out and they are a record rather than a control — which is what
+     * they are once the message has been sent.
+     */
+    onRemove?: (id: string) => void;
+    labels?: Partial<Labels>;
+}
+/**
+ * `1.2 MB`, and nothing for a size nobody supplied.
+ *
+ * Powers of two, because that is what a file browser says and this number is
+ * only ever compared to one of those.
+ */
+export declare function formatSize(bytes?: number): string;
+/**
+ * What is going along with the message.
+ *
+ * An image shows itself; everything else shows its name, because a thumbnail
+ * of a PDF at this size is a grey rectangle with a corner turned down and
+ * tells you less than the filename does.
+ *
+ * The same row draws them in the composer and under the message once it has
+ * been sent — with `onRemove` in the first case and without in the second,
+ * which is the whole difference between a control and a record.
+ */
+export declare function Attachments({ attachments, onRemove, labels, className, ...rest }: AttachmentsProps): import("react").JSX.Element | null;
+export {};

package/dist/Branch/Branch.d.ts

@@ -0,0 +1,28 @@
+import { HTMLAttributes } from 'react';
+type Labels = {
+    previous: string;
+    next: string;
+    /** `{index}` and `{total}` are filled in. */
+    position: string;
+};
+export interface BranchProps extends Omit<HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /** How many answers this turn has had. */
+    total: number;
+    /** Which one is on screen, from zero. */
+    index: number;
+    onSelect: (index: number) => void;
+    labels?: Partial<Labels>;
+}
+/**
+ * Which answer you are looking at, and how to reach the others.
+ *
+ * Regenerating used to overwrite: the answer you were comparing against was
+ * gone the moment the second one started. But the reason anybody presses
+ * regenerate is to find out whether a second attempt is better, and there is
+ * no better once the first has been thrown away.
+ *
+ * So it draws nothing at all for a turn with one answer. A control that says
+ * "1 of 1" is a control offering to take you nowhere.
+ */
+export declare function Branch({ total, index, onSelect, labels, className, ...rest }: BranchProps): import("react").JSX.Element | null;
+export {};

package/dist/Button/Button.d.ts

@@ -0,0 +1,23 @@
+import { ButtonHTMLAttributes, ReactNode } from 'react';
+export type ButtonVariant = "primary" | "secondary" | "outline" | "ghost" | "glass";
+/**
+ * Heights: xs 24, s 28, m 32, l 40, xl 48.
+ *
+ * One scale, from two that disagreed — the round icon button was 28 with no
+ * say in the matter, and the glass pill offered 32/40/48 under the names
+ * s/m/l. Both sets of values survive; only the glass names moved up one step,
+ * which is what the deprecated `GlassButton` wrapper exists to absorb.
+ */
+export type ButtonSize = "xs" | "s" | "m" | "l" | "xl";
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    /** Leading icon. On its own it makes a square button; give it an aria-label. */
+    icon?: ReactNode;
+    /** Trailing icon. */
+    iconRight?: ReactNode;
+    /** Replaces the content with a spinner and refuses interaction. */
+    loading?: boolean;
+    children?: ReactNode;
+}
+export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/ChainOfThought/ChainOfThought.d.ts

@@ -0,0 +1,49 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { WorkState } from '../stateGlyph/StateGlyph';
+/** One step of a derivation: what was worked out, and the working. */
+export interface Thought {
+    id: string;
+    /** What this step established. One line. */
+    label: ReactNode;
+    /** The working behind it. Prose, or anything you want drawn — a `Tool`, say. */
+    body?: ReactNode;
+    /** Defaults to `done`: a step you can read is a step that happened. */
+    state?: WorkState;
+}
+type Labels = {
+    /** Followed by the count: "Thought through 4 steps". */
+    through: string;
+    step: string;
+    steps: string;
+    thinking: string;
+};
+export interface ChainOfThoughtProps extends Omit<HTMLAttributes<HTMLElement>, "title"> {
+    steps: Thought[];
+    /** The chain as a whole. `thinking` holds it open and narrates the last step. */
+    state?: "thinking" | "done";
+    /** How long the whole chain took, in ms. */
+    duration?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    labels?: Partial<Labels>;
+}
+/**
+ * How the answer was arrived at, step by step.
+ *
+ * The third thing in this kit that draws a sequence, and the line between them
+ * is worth stating because it is the only reason there are three:
+ *
+ * - **`Reasoning`** is prose. The model talking to itself, unstructured.
+ * - **`TaskList`** is a plan. Known up front, forward-looking, fixed order,
+ *   items changing state as work happens.
+ * - **`ChainOfThought`** is a derivation. Backward-looking, and it *grows* —
+ *   each step follows from the one above it, which is what the line down the
+ *   side is drawing. A step carries its own working, not a footnote.
+ *
+ * Open while it thinks and folded away once the answer starts, on the same
+ * terms as `Reasoning`: the chain's preference, overruled for good by anybody
+ * who touches it.
+ */
+export declare function ChainOfThought({ steps, state, duration, open, defaultOpen, onOpenChange, labels, className, ...rest }: ChainOfThoughtProps): import("react").JSX.Element;
+export {};

package/dist/ChatHeader/ChatHeader.d.ts

@@ -0,0 +1,89 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export type ChatHeaderVariant = "plain" | "glass" | "bordered";
+export type ChatHeaderSize = "s" | "m" | "l";
+/**
+ * One action in the end region.
+ *
+ * Described rather than handed over as a node, and the reason is not tidiness:
+ * a header that is given arbitrary children cannot fold them into an overflow
+ * menu when the space runs out, because it has no idea what any of them are —
+ * no label to list, no icon to draw. Everything `collapseActionsAt` does
+ * depends on this shape.
+ */
+export interface ChatHeaderAction {
+    /** Stable across renders. Also the React key and the menu item's id. */
+    id: string;
+    /**
+     * The accessible name, and the text used in the overflow menu.
+     *
+     * Not optional. An icon button has no name of its own, and a header full of
+     * unlabelled glyphs is a header a screen reader reads as "button, button,
+     * button".
+     */
+    label: string;
+    icon: ReactNode;
+    onClick?: () => void;
+    /** Renders an anchor rather than a button. Navigation is not a click. */
+    href?: string;
+    /**
+     * A number worth showing on the glyph — saved bookmarks, unread replies.
+     * It is folded into the accessible name too: the badge is decorative, and a
+     * reader who cannot see it would otherwise lose the count entirely.
+     */
+    count?: number;
+    /** A toggle rather than a command. Renders `aria-pressed`. */
+    active?: boolean;
+    disabled?: boolean;
+    /** Stays visible when the rest collapse. For the one action that matters. */
+    pinned?: boolean;
+}
+export interface ChatHeaderProps extends Omit<HTMLAttributes<HTMLElement>, "title" | "children"> {
+    /** What the conversation is about, so the reader can see where they are. */
+    title?: ReactNode;
+    /** The second line: the model, a count, a state. */
+    subtitle?: ReactNode;
+    /** Logo or agent avatar, drawn before the title. */
+    avatar?: ReactNode;
+    /**
+     * How the title is exposed to assistive technology. A heading is what makes
+     * the conversation reachable by heading navigation; the level belongs to the
+     * host's document, not to us, so it is a prop. `false` renders plain text.
+     */
+    headingLevel?: 1 | 2 | 3 | 4 | 5 | 6 | false;
+    /** Long titles get an ellipsis rather than a second line. */
+    truncate?: boolean;
+    /** Renders a back button. */
+    onBack?: () => void;
+    /** Renders a back link instead — navigation belongs in an anchor. */
+    backHref?: string;
+    backLabel?: string;
+    /** The managed actions. These are what collapse. */
+    actions?: ChatHeaderAction[];
+    overflowLabel?: string;
+    variant?: ChatHeaderVariant;
+    size?: ChatHeaderSize;
+    /** `center` is the native/mobile arrangement: title centred, actions apart. */
+    align?: "start" | "center";
+    sticky?: boolean;
+    /** Grow a border and a backdrop once the conversation has scrolled under it. */
+    elevateOnScroll?: boolean;
+    /**
+     * Width, in pixels, below which unpinned actions fold into an overflow menu.
+     * `false` never folds. Measured on the header itself, not the viewport, so
+     * a header in a narrow panel collapses on its own terms.
+     */
+    collapseActionsAt?: number | false;
+    /**
+     * Render as `<header>`, which is a `banner` landmark at the top level of a
+     * page. Set `false` for a header inside a panel or a card, where claiming
+     * the page's banner would be a lie.
+     */
+    landmark?: boolean;
+    /**
+     * Anything the kit should not manage — a segmented control, a model picker.
+     * Sits in the end region before the actions, and never collapses: the kit
+     * cannot summarise what it cannot read.
+     */
+    children?: ReactNode;
+}
+export declare const ChatHeader: import('react').ForwardRefExoticComponent<ChatHeaderProps & import('react').RefAttributes<HTMLElement>>;

package/dist/ChatInput/AddCardsOverlay.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+import { InlineAnimConfig } from './ChatInput';
+export interface AddCardsOverlayProps {
+    isAddOpen: boolean;
+    setIsAddOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    onAdd?: (label?: string) => void;
+    showInlineGlyph: boolean;
+    showButtons: boolean;
+    ac: InlineAnimConfig | undefined;
+}
+export declare function AddCardsOverlay({ isAddOpen, setIsAddOpen, onAdd, showInlineGlyph, showButtons, ac, }: AddCardsOverlayProps): React.JSX.Element;

package/dist/ChatInput/ChatInput.d.ts

@@ -0,0 +1,118 @@
+import { Attachment } from '../Attachments/Attachments';
+import { TranscribeHandler } from '../voice/useVoiceInput';
+export type ChatInputState = "idle" | "typing" | "responding" | "resting";
+export interface InlineAnimConfig {
+    bubble: {
+        stiffness: number;
+        damping: number;
+        mass: number;
+    };
+    button: {
+        stiffness: number;
+        damping: number;
+        mass: number;
+        staggerEnter: number;
+        staggerExit: number;
+    };
+    addButton: {
+        duration: number;
+        visualDuration: number;
+        bounce: number;
+    };
+    enterButton: {
+        duration: number;
+        visualDuration: number;
+        bounce: number;
+    };
+    ripple: {
+        scaleX: number;
+        duration: number;
+        pulseDuration: number;
+    };
+    wrap: {
+        nearThreshold: number;
+        exitThreshold: number;
+        preExpandHeight: number;
+        slideInDelay: number;
+        /**
+         * How long the controls take to leave when the composer grows into a
+         * second line, in seconds.
+         *
+         * It was a literal `0.15` in three places, which is why the exit could not
+         * be tuned while everything around it could: the dial reached the springs
+         * that bring the row back and nothing that takes it away.
+         */
+        exitDuration: number;
+    };
+    actions: {
+        staggerDelay: number;
+        duration: number;
+        stiffness: number;
+        damping: number;
+    };
+    addCards: {
+        staggerDelay: number;
+        stiffness: number;
+        damping: number;
+        inputScale: number;
+        inputBlur: number;
+        angle1: number;
+        angle2: number;
+        angle3: number;
+        hoverPull: number;
+    };
+}
+export declare const defaultInlineAnimConfig: InlineAnimConfig;
+export interface ChatInputHandle {
+    focus: (options?: FocusOptions) => void;
+    setValue: (value: string) => void;
+    getValue: () => string;
+}
+export interface ChatInputProps {
+    state: ChatInputState;
+    value: string;
+    onChange: (value: string) => void;
+    /**
+     * What was typed, and what is going with it.
+     *
+     * The second argument is the whole reason attachments exist: before it, one
+     * could be picked and shown in the composer and then quietly dropped on
+     * send, which is worse than not offering it.
+     */
+    onSubmit: (value: string, attachments: Attachment[]) => void;
+    onStop?: () => void;
+    onAdd?: () => void;
+    /**
+     * What is attached, controlled. Leave it out and the composer keeps its own
+     * — the same rule `useDisclosure` follows.
+     */
+    attachments?: Attachment[];
+    /**
+     * Files somebody picked. Given, this is called instead of the composer
+     * attaching them itself — for a host that wants to upload first and attach
+     * the URL it gets back.
+     */
+    onAttach?: (files: File[]) => void;
+    onRemoveAttachment?: (id: string) => void;
+    /** Passed to the file picker. Defaults to images. */
+    accept?: string;
+    /** More than one at a time. Off by default. */
+    multiple?: boolean;
+    /**
+     * Audio in, words out. Given, the composer offers a microphone where the
+     * send glyph would be while there is nothing to send; left out, there is no
+     * microphone at all — the same rule `onRemove` follows on `<Attachments>`.
+     *
+     * The kit records and hands over a `Blob`; what it does with the audio is
+     * the half a host owns. See `useVoiceInput`.
+     */
+    onTranscribe?: TranscribeHandler;
+    onCopy?: (value: string) => void;
+    onEdit?: (value: string) => void;
+    onCancelEdit?: () => void;
+    isEditing?: boolean;
+    placeholder?: string;
+    animationConfig?: InlineAnimConfig;
+    style?: React.CSSProperties;
+}
+export declare const ChatInput: import('react').ForwardRefExoticComponent<ChatInputProps & import('react').RefAttributes<ChatInputHandle>>;

package/dist/ChatInput/HoverActionsRow.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { InlineAnimConfig } from './ChatInput';
+export interface HoverActionsRowProps {
+    showActions: boolean;
+    showReadMore: boolean;
+    isExpanded: boolean;
+    setIsExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+    onCopy?: (value: string) => void;
+    onEdit?: (value: string) => void;
+    value: string;
+    ac: InlineAnimConfig | undefined;
+}
+export declare function HoverActionsRow({ showActions, showReadMore, isExpanded, setIsExpanded, onCopy, onEdit, value, ac, }: HoverActionsRowProps): React.JSX.Element;

package/dist/ChatInput/MorphGlyph.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Glyph slot for the send/stop/check action. Static Lucide icons swap
+ * with a vertical slide + fade — outgoing slides up and out, incoming
+ * slides up from below. Single slot, single transition.
+ */
+export interface MorphGlyphProps {
+    mode: "send" | "stop" | "check" | "mic";
+    /** Icon colour. Inherits from whatever contains it unless set. */
+    color?: string;
+    /** Slide duration in seconds. */
+    duration?: number;
+    /** Icon pixel size. */
+    size?: number;
+}
+export declare function MorphGlyph({ mode, color, duration, size, }: MorphGlyphProps): import("react").JSX.Element;