altitude-design 0.2.0 → 0.3.0

package/dist/types-cjs/controls.d.cts

@@ -0,0 +1,360 @@
+import * as React from 'react';
+import { DepthProps } from './core.cjs';
+import { Promised, SkeletonOption } from './suspense.cjs';
+export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: 'primary' | 'secondary' | 'ghost' | 'danger';
+    size?: 'sm' | 'md' | 'lg';
+    /** Icon-only: a square button. Give it an aria-label. */
+    square?: boolean;
+    loading?: boolean;
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+}
+export declare const Button: React.ForwardRefExoticComponent<ButtonProps & React.RefAttributes<HTMLButtonElement>>;
+export interface CardProps extends React.HTMLAttributes<HTMLDivElement>, DepthProps {
+    /** Lifts on hover and presses on click. Only set it when the whole card does something. */
+    interactive?: boolean;
+    /**
+     * The card holds a Suspense boundary: while anything of yours inside it suspends, the card stays up and its body is an
+     * imprint (a title line and `lines` lines of text, default 3). `false` lets it suspend to your own boundary.
+     * It's also a loading scope: its optional parts (description, body text) wait while its required parts do.
+     */
+    skeleton?: SkeletonOption;
+}
+export declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+export declare const CardHeader: ({ className, ...p }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+/**
+ * Text that may still be on its way: `undefined` while your data loads (`{user?.name}`), a promise, or one promise among
+ * plain text. `null` renders nothing.
+ */
+type PromisedText<E> = Omit<React.HTMLAttributes<E>, 'children'> & {
+    children?: React.ReactNode | PromiseLike<React.ReactNode> | Array<React.ReactNode | PromiseLike<React.ReactNode>>;
+    /** While the text is on its way, its imprint: `lines` (one for a title, two for a description) and `width`. `false`: render what you pass as it is, and let promises suspend to your own boundary. */
+    skeleton?: SkeletonOption;
+};
+export declare const CardTitle: ({ className, children, skeleton, ...p }: PromisedText<HTMLHeadingElement>) => React.JSX.Element;
+export declare const CardDescription: ({ className, children, skeleton, ...p }: PromisedText<HTMLParagraphElement>) => React.JSX.Element;
+export interface CardContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** The body holds a Suspense boundary: while anything of yours inside it suspends, or its text (`{user?.bio}`) is undefined while the card's other parts are, it's `lines` lines of imprint (default 3). `false` suspends to your own boundary. */
+    skeleton?: SkeletonOption;
+}
+export declare const CardContent: ({ className, skeleton, children, ...p }: CardContentProps) => React.JSX.Element;
+export declare const CardFooter: ({ className, ...p }: React.HTMLAttributes<HTMLDivElement>) => React.JSX.Element;
+export interface SuggestionProps {
+    /**
+     * A value proposed for this field (by an AI feature, autofill, a template), drawn as a ghost of the value in ink-faint:
+     * the whole value while the field is empty (or the rest of it while what's typed matches its start), or after the text
+     * with suggestionMode="append". Tab accepts, Escape dismisses, typing carries on past it. It's never put in the value,
+     * so an empty field with a ghost is still an opening.
+     */
+    suggestion?: string;
+    /** 'replace' (default): the suggestion is the whole value. 'append': it continues the text. */
+    suggestionMode?: 'replace' | 'append';
+    /** Called with the new value when Tab accepts (onChange is called too). */
+    onAcceptSuggestion?: (value: string) => void;
+}
+export interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'>, SuggestionProps {
+    invalid?: boolean;
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+    size?: 'sm' | 'md';
+}
+export declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement>, SuggestionProps {
+    invalid?: boolean;
+    /** With maxLength, the well fills from the bottom as the text approaches the limit, and shows a count. Default true. */
+    showFill?: boolean;
+}
+/** A deep well. With a maxLength it shows how full it is: a fill line rises from the floor as you type. */
+export declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export interface FieldProps {
+    label: React.ReactNode;
+    hint?: React.ReactNode;
+    /** When set, the control turns invalid and the message emerges beneath it. */
+    error?: React.ReactNode;
+    required?: boolean;
+    className?: string;
+    children: React.ReactElement<any>;
+}
+export declare function Field({ label, hint, error, required, className, children }: FieldProps): React.JSX.Element;
+export interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'onChange'> {
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    indeterminate?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    onChange?: React.ChangeEventHandler<HTMLInputElement>;
+}
+/** Built like the Switch and RadioGroup: an empty trench when off; checking pours the accent in and sets a raised white check on it. */
+export declare const Checkbox: React.ForwardRefExoticComponent<CheckboxProps & React.RefAttributes<HTMLInputElement>>;
+export interface RadioGroupProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (v: string) => void;
+    name?: string;
+    disabled?: boolean;
+    orientation?: 'vertical' | 'horizontal';
+}
+/** A switch with several positions: one raised thumb slides to the chosen option and the accent pours in behind it. */
+export declare function RadioGroup({ value, defaultValue, onValueChange, name, disabled, orientation, className, children, ...rest }: RadioGroupProps): React.JSX.Element;
+export interface RadioProps {
+    value: string;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function Radio({ value, label, description, disabled, className }: RadioProps): React.JSX.Element;
+export interface SwitchProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (v: boolean) => void;
+    label?: React.ReactNode;
+}
+export declare function Switch({ checked, defaultChecked, onCheckedChange, label, className, disabled, ...rest }: SwitchProps): React.JSX.Element;
+export interface TabsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'defaultValue'> {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (v: string) => void;
+    /**
+     * folder (default): each tab is the top edge of its own sheet; the chosen tab and its panel are one raised piece.
+     * Put TabsContent directly after TabsList. segmented: the options sit in a well and a raised pill glides between them.
+     */
+    variant?: 'folder' | 'segmented';
+}
+export declare function Tabs({ value, defaultValue, onValueChange, variant, className, children, ...rest }: TabsProps): React.JSX.Element;
+export declare function TabsList({ className, children, ...rest }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+export declare function TabsTrigger({ value, className, children, ...rest }: React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    value: string;
+}): React.JSX.Element;
+export declare function TabsContent({ value, forceMount, className, ...rest }: React.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+    forceMount?: boolean;
+}): React.JSX.Element | null;
+export interface SliderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (v: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    /** Format the value shown in the bubble that floats above the thumb while dragging. */
+    format?: (v: number) => React.ReactNode;
+    'aria-label'?: string;
+}
+/** A range: two thumbs with the raised fill between them. */
+export interface SliderRangeProps extends Omit<SliderProps, 'value' | 'defaultValue' | 'onValueChange' | 'aria-label'> {
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onValueChange?: (v: [number, number]) => void;
+    /** Steps the thumbs keep between them, so they can't meet. Default 0. */
+    minStepsBetween?: number;
+    /** A name per thumb, or one name for the pair (each thumb is then "<name>, minimum" and "<name>, maximum"). */
+    'aria-label'?: string | [string, string];
+}
+export declare function Slider(props: SliderProps): React.ReactElement;
+export declare function Slider(props: SliderRangeProps): React.ReactElement;
+/** Two values on one track: what the range Slider and ChartBrush share. A thumb can't cross the other or come within
+ *  `minStepsBetween` of it; dragging between the thumbs pans both; pressing outside them moves the nearer one there,
+ *  or with `outside: 'centre'` centres the pair there and pans from it. */
+export declare function useRange({ value, defaultValue, onValueChange, min, max, step, minStepsBetween, disabled, outside }: {
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onValueChange?: (v: [number, number]) => void;
+    min: number;
+    max: number;
+    step: number;
+    minStepsBetween?: number;
+    disabled?: boolean;
+    outside?: 'nearer' | 'centre';
+}): {
+    value: [number, number];
+    set: (v: [number, number]) => void;
+    held: 0 | 1 | "both" | "tie" | null;
+    track: React.RefObject<HTMLDivElement | null>;
+    bounds: (i: 0 | 1) => [number, number];
+    pct: (n: number) => number;
+    press: (e: React.PointerEvent<HTMLElement>, thumb?: 0 | 1) => 0 | 1 | "both" | undefined;
+    drag: (e: React.PointerEvent<HTMLElement>) => void;
+    release: () => void;
+    keys: (i: 0 | 1) => (e: React.KeyboardEvent) => void;
+    shift: (d: number) => void;
+};
+export interface ProgressProps extends React.HTMLAttributes<HTMLDivElement> {
+    value?: number | null;
+    max?: number;
+    'aria-label'?: string;
+}
+export declare function Progress({ value, max, className, ...rest }: ProgressProps): React.JSX.Element;
+export interface BadgeProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'children'> {
+    tone?: 'neutral' | 'accent' | 'positive' | 'caution' | 'critical';
+    /**
+     * plate (default): an indicator plate set flush into the page. tinted: the plate takes its tone's colour.
+     * outline: a hairline only. count: a number that wants attention; it floats above the page and pops when it changes.
+     * ('soft' is the old name for tinted.)
+     */
+    variant?: 'plate' | 'tinted' | 'outline' | 'count' | 'soft';
+    /** The indicator lamp. On by default for positive, caution and critical; true on a neutral badge shows an unlit lamp. 'pulse' breathes, for something in progress. */
+    lamp?: boolean | 'pulse';
+    /** @deprecated Use `lamp`. */
+    dot?: boolean;
+    /** The label. Undefined while your data loads, or a promise: until it arrives the badge is a plate-shaped imprint. */
+    children?: React.ReactNode | PromiseLike<React.ReactNode> | Array<React.ReactNode | PromiseLike<React.ReactNode>>;
+    /** While the label is on its way: the imprint's `width` (default 64px; a count is round). `false`: render what you pass as it is, and let promises suspend to your own boundary. */
+    skeleton?: SkeletonOption;
+}
+/** A label stamped into the record. Status carries a lamp that relights when it changes; a changed label is re-stamped. */
+export declare function Badge({ children, skeleton, ...props }: BadgeProps): React.JSX.Element;
+export interface AvatarProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** The accessible label. Undefined while your data loads (`user?.name`), or a promise: until it arrives the avatar is an imprint of its size and shape. */
+    name: Promised<string> | undefined;
+    /** May be a promise, like `name`. If the image fails to load, the initials show instead. */
+    src?: Promised<string | undefined>;
+    /** In pixels. Default 36. */
+    size?: number;
+    /** `circle` (default) for a person; `square` for a team, an organisation, a bot or an agent. */
+    shape?: 'circle' | 'square';
+    /** Presence: active and idle people are here, so they rest on the page (a filled lamp or an empty one says which); offline people lie flat in it, grey. */
+    status?: 'active' | 'idle' | 'offline';
+    /** Speaking, typing or presenting right now: the face leaves the ground and drifts above its shadow. */
+    live?: boolean;
+    /** Ties the person to their presence colour, the same ring they wear on anything they're holding. */
+    presence?: 1 | 2 | 3;
+    /** The status lamp (filled green active, empty amber ring idle). Default: shown when there is a status and the avatar is 24px or larger. Never shown inside AvatarGroup. */
+    lamp?: boolean;
+    /** `false`: no imprint. An undefined `name` renders an empty face; a promised one suspends to your own boundary. */
+    skeleton?: boolean;
+}
+/** A disc resting on the page while the person is here, flush in it when they're not; live, it lifts off its shadow. */
+export declare function Avatar({ skeleton, ...props }: AvatarProps): React.JSX.Element;
+export interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Show at most this many faces; the rest become a "+N" plate that names them. */
+    max?: number;
+    /** In pixels, for every face that doesn't set its own. Default: the first face's size, or 36. */
+    size?: number;
+}
+/** Faces standing on one ground line, each cut out of the one before it. */
+export declare function AvatarGroup({ className, children, max, size: groupSize, style, ...rest }: AvatarGroupProps): React.JSX.Element;
+export interface SkeletonProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** When it turns true, the children rise out of the imprint into place. */
+    loaded?: boolean;
+    shape?: 'block' | 'text' | 'circle';
+    /** For shape="text": how many lines to imprint. */
+    lines?: number;
+    width?: number | string;
+    height?: number | string;
+    radius?: string;
+}
+/** An imprint of the content to come, pressed into the page; when the content arrives it rises out of its imprint. */
+export declare function Skeleton({ loaded, shape, lines, width, height, radius, className, style, children, ...rest }: SkeletonProps): React.JSX.Element;
+export interface AlertProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'>, Pick<DepthProps, 'settle'> {
+    tone?: 'neutral' | 'accent' | 'positive' | 'caution' | 'critical';
+    /** flat (default): a sheet laid on the page, it informs. raised: a card above the page, it asks you to act. */
+    variant?: 'flat' | 'raised';
+    title?: React.ReactNode;
+    action?: React.ReactNode;
+    icon?: React.ReactNode;
+    /** Shows a dismiss button; the sheet lifts off the page and the gap closes, then this is called. */
+    onDismiss?: () => void;
+    /** The dismiss button's words ("Remind me tomorrow"). Default: an × named "Dismiss". */
+    dismissLabel?: string;
+    /** 'page': a banner for the whole app or page, edge to edge with no side rounding, in a labelled region. Default 'inline'. */
+    placement?: 'inline' | 'page';
+    /** With placement="page": stays at the top while the page scrolls. */
+    sticky?: boolean;
+}
+/** Status as a sheet laid on the page: it rests on the ground (you can see its edge and its contact shadow) and never floats. When it asks the person to act it becomes a raised card. */
+export declare function Alert({ tone, variant, title, action, icon, onDismiss, dismissLabel, placement, sticky, settle, className, style, children, ...rest }: AlertProps): React.JSX.Element;
+export interface AlertStackProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Alert elements, most important first. Give each a key. */
+    children: React.ReactNode;
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Label for the count while stacked. Default "+N more". */
+    moreLabel?: (hidden: number) => React.ReactNode;
+    /** Label for collapsing. Default "Show less". */
+    lessLabel?: React.ReactNode;
+    /** 'page': a stack of page banners, edge to edge. Give each Alert placement="page" too. */
+    placement?: 'inline' | 'page';
+}
+/**
+ * Several alerts as a stack of sheets: the first lies on top and the others peek out beneath it, each tinted by its
+ * own tone, with a count. Opening the stack fans them out; dismissing the top one lifts it off and the next comes up.
+ */
+export declare function AlertStack({ children, expanded, defaultExpanded, onExpandedChange, moreLabel, lessLabel, placement, className, ...rest }: AlertStackProps): React.JSX.Element;
+export interface AccordionItem {
+    value: string;
+    title: React.ReactNode;
+    content: React.ReactNode;
+}
+export interface AccordionProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'defaultValue'> {
+    items: AccordionItem[];
+    type?: 'single' | 'multiple';
+    defaultValue?: string[];
+}
+export declare function Accordion({ items, type, defaultValue, className, ...rest }: AccordionProps): React.JSX.Element;
+export interface HoldButtonProps extends Omit<ButtonProps, 'loading'> {
+    /** Called once the button has been held for `duration`. */
+    onConfirm: () => void;
+    /** Milliseconds. Default 1000 (dur-hold). */
+    duration?: number;
+    holdingLabel?: React.ReactNode;
+    doneLabel?: React.ReactNode;
+    /**
+     * By default a completed hold is final: the button settles flat, shows doneLabel and can't be pressed again.
+     * Set true for actions that can be repeated; the button re-arms after a moment.
+     */
+    repeatable?: boolean;
+}
+/** Commitment as depth: holding pushes the button down through the ground into a trench. Let go early and it springs back. */
+export declare function HoldButton({ onConfirm, duration, variant, holdingLabel, doneLabel, repeatable, className, children, style, disabled, onClick, ...rest }: HoldButtonProps): React.JSX.Element;
+export interface ScrollAreaProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** A header that sits flush at the top and rises once content scrolls beneath it. */
+    header?: React.ReactNode;
+    maxHeight?: number | string;
+    'aria-label'?: string;
+}
+/** Overflow as depth: where content continues past an edge, the edge curves away (an inner lip); content passing under the header lifts it. */
+export declare function ScrollArea({ header, maxHeight, className, children, ...rest }: ScrollAreaProps): React.JSX.Element;
+export interface DropZoneProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onDrop'> {
+    onFiles?: (files: File[]) => void;
+    accept?: string;
+    multiple?: boolean;
+    /** Force a visual state, for documentation: idle, armed (a file is being dragged somewhere on the page) or over. */
+    state?: 'idle' | 'armed' | 'over';
+    /** The files you're handling, shown as slats under the zone: uploading (a Progress fill), processing (hovering, pending), done (lands and settles) or failed (a trench with Retry). */
+    queue?: UploadItem[];
+    onRetry?: (id: string) => void;
+    onCancel?: (id: string) => void;
+    onRemove?: (id: string) => void;
+}
+export interface UploadItem {
+    id: string;
+    name: string;
+    /** Bytes. */
+    size?: number;
+    state: 'uploading' | 'processing' | 'done' | 'failed';
+    /** 0–100, while uploading. */
+    progress?: number;
+    /** Why it failed, in words. */
+    error?: string;
+}
+/** Receptacles open when they're needed: a drop zone is flush until a file is dragged anywhere on the page, then sinks open; over it, it deepens. */
+export declare function DropZone({ onFiles, accept, multiple, state, queue, onRetry, onCancel, onRemove, className, children, ...rest }: DropZoneProps): React.JSX.Element;
+export interface SortableListProps<T> {
+    items: T[];
+    getKey: (item: T) => string;
+    onReorder: (items: T[]) => void;
+    renderItem: (item: T, state: {
+        held: boolean;
+    }) => React.ReactNode;
+    /** Accessible name for each item, used in announcements. */
+    getLabel?: (item: T) => string;
+    gap?: number;
+    className?: string;
+    'aria-label'?: string;
+}
+/** Possession as depth: the item you pick up comes into your hand (level 3), the slot it will land in opens as a well, and it lands with a settle. */
+export declare function SortableList<T>({ items, getKey, onReorder, renderItem, getLabel, gap, className, ...rest }: SortableListProps<T>): React.JSX.Element;
+export {};

package/dist/types-cjs/conversation.d.cts

@@ -0,0 +1,130 @@
+import * as React from 'react';
+export interface ConversationProps extends React.HTMLAttributes<HTMLDivElement> {
+    'aria-label': string;
+}
+/**
+ * The thread between a person and an assistant. Settled messages are the record. It follows new text to the bottom
+ * until the person scrolls up, then offers "Jump to latest". A streamed answer is announced once, when it completes,
+ * never token by token.
+ */
+export declare function Conversation({ className, children, 'aria-label': label, ...rest }: ConversationProps): React.JSX.Element;
+/** The messages, in order. */
+export declare function ConversationContent({ className, ...rest }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+/** "Jump to latest message": floats at level 3 once the person has scrolled up from the bottom. */
+export declare function ConversationScrollButton({ className }: {
+    className?: string;
+}): React.JSX.Element | null;
+export type MessageStatus = 'streaming' | 'complete' | 'stopped' | 'error';
+export interface MessageProps extends React.HTMLAttributes<HTMLElement> {
+    from: 'user' | 'assistant';
+    /** An assistant message: streaming rests on the ground with a dashed rule, "Generating…" and a caret; complete settles with one afterglow; stopped and error are kept, with Retry. Default 'complete'. */
+    status?: MessageStatus;
+    /** Who's speaking. Default "You" or "Assistant". */
+    name?: string;
+    onRetry?: () => void;
+    /** A person's message that was edited and resent: "Edited" in its caption. */
+    edited?: boolean;
+}
+/**
+ * One message. A person's is a flush accent-soft sheet; an assistant's is flush, no bubble. While an answer streams it
+ * isn't the record yet: it rests on the ground with a dashed rule down its edge (charts' "not yet the record"), never
+ * hovering, because nothing you sent is in flight. When it completes the rule goes solid and it settles once.
+ */
+export declare function Message({ from, status, name, onRetry, edited, className, children, ...rest }: MessageProps): React.JSX.Element;
+export interface MessageAttachment {
+    name: string;
+    /** Its MIME type: image/* with a `url` shows as a thumbnail; anything else as a file plate. */
+    type?: string;
+    /** In bytes, shown on a file plate. */
+    size?: number;
+    /** An image's thumbnail. */
+    url?: string;
+    /** An image's text alternative. Default its name. */
+    alt?: string;
+    /** Opens the file as a link. */
+    href?: string;
+    /** Opens the file in the app (a preview Dialog, say). */
+    onOpen?: () => void;
+    /** Expired or deleted: "No longer available", and it doesn't act. */
+    unavailable?: boolean;
+}
+export interface MessageAttachmentsProps extends Omit<React.HTMLAttributes<HTMLUListElement>, 'children'> {
+    items: MessageAttachment[];
+}
+/**
+ * What went with a message: the files the composer showed as plates, now settled into the record. Images are 64px
+ * thumbnails, other files Tag plates with name, type and size; those with href or onOpen act (and lift one level when
+ * pointed at). Put it before MessageContent. A sent attachment was uploaded before the message went, so it's never
+ * pending.
+ */
+export declare function MessageAttachments({ items, className, ...rest }: MessageAttachmentsProps): React.JSX.Element | null;
+/** The message's text. Text arrives without per-word animation; a caret marks the end while it streams. */
+export declare function MessageContent({ className, children, ...rest }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+export interface ConversationCheckpointProps {
+    /** What the point is before: "Before editing 6 files". */
+    label: string;
+    /** When it was made. */
+    at?: Date | string | number;
+    /** What restoring does, in words: "The 4 messages after this and the changes to 6 files will be set aside. You can return to them." */
+    consequence: string;
+    /** Restore: resolve when done, reject (with a message) when it couldn't. */
+    onRestore: () => void | Promise<unknown>;
+    /**
+     * Real recovery: bring back what restoring set aside. With it, Restore runs at once and leaves "Return to where you
+     * were"; without it, Restore asks first in a Dialog.
+     */
+    onReturn?: () => void | Promise<unknown>;
+    locale?: string;
+    className?: string;
+}
+/**
+ * A point in the conversation to go back to (#277): a divider with a word between its lines ("Checkpoint · Before
+ * editing 6 files · 2:14 PM") and Restore. Restoring follows the consequential-action contract: with onReturn it runs at
+ * once and leaves "Return to where you were"; without, it asks in a stationary Dialog. While restoring the label hovers
+ * as pending; restored, it settles once; failed, it sinks into a trench with Retry. Set the later turns aside as a
+ * branch (the next message's versions) rather than deleting them.
+ */
+export declare function ConversationCheckpoint({ label, at, consequence, onRestore, onReturn, locale, className }: ConversationCheckpointProps): React.JSX.Element;
+export interface QueuedMessage {
+    id: string;
+    text: string;
+}
+export interface ConversationQueueProps {
+    /** Messages written while the agent worked, in the order they'll be sent. */
+    items: QueuedMessage[];
+    /** Stop the current turn and send this one now. */
+    onSendNow?: (id: string) => void;
+    /** Edit opens it in place; called with the new text. */
+    onEdit?: (id: string, text: string) => void;
+    onRemove?: (id: string) => void;
+    className?: string;
+}
+/**
+ * Messages queued while the agent works (#276), between the thread and the composer, in order, each with Send now,
+ * Edit and Remove. A queued message is written but not dispatched, so it doesn't hover (pending is for a write in
+ * flight): it's the person's sheet on the ground with a dashed rim, "Queued · 1 of 2". Your app sends the first when
+ * the turn ends, and it becomes an ordinary message in the log.
+ */
+export declare function ConversationQueue({ items, onSendNow, onEdit, onRemove, className }: ConversationQueueProps): React.JSX.Element | null;
+export interface MessageActionsProps {
+    /** Shows Copy (the message's text, or this value). */
+    onCopy?: boolean | (() => string);
+    onRegenerate?: () => void;
+    /** Shows good / bad response toggles; null when cleared. */
+    onFeedback?: (value: 'up' | 'down' | null) => void;
+    feedback?: 'up' | 'down' | null;
+    /**
+     * Regenerated answers, or a person's edited message, are kept as versions, never overwritten: "Version 2 of 2".
+     * Switching is announced ("Showing version 1 of 2").
+     */
+    versions?: {
+        index: number;
+        total: number;
+        onChange: (index: number) => void;
+    };
+    /** A person's message: an Edit action that opens it in place; sending the edit calls this with the new text (start a branch from it). */
+    onEdit?: (text: string) => void;
+    className?: string;
+}
+/** Copy, regenerate, feedback and versions: ghost buttons that lift when pointed at. Hidden while the message streams. */
+export declare function MessageActions({ onCopy, onRegenerate, onFeedback, feedback, versions, onEdit, className }: MessageActionsProps): React.JSX.Element | null;

package/dist/types-cjs/copy-button.d.cts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { ButtonProps } from './controls.cjs';
+export interface CopyButtonProps extends Omit<ButtonProps, 'value' | 'onCopy' | 'onError' | 'square' | 'loading' | 'leading'> {
+    /** What's copied, or a function that returns it (it may return a promise). */
+    value: string | (() => string | Promise<string>);
+    /** The button's name: its aria-label and Tooltip when it's icon-only, and kept as its name while it says "Copied". Default "Copy". */
+    label?: string;
+    /** Shown for dur-linger once copied. Default "Copied". */
+    copiedLabel?: string;
+    /** Shown for dur-linger when copying fails. Default "Couldn't copy". */
+    failedLabel?: string;
+    onCopy?: (value: string) => void;
+    onError?: (error: unknown) => void;
+}
+/**
+ * Copies a value and says so in words: pressed to the ground with a check and "Copied" for dur-linger, announced
+ * politely while the button keeps its name. No rise and no afterglow: nothing new arrived on the page.
+ */
+export declare const CopyButton: React.ForwardRefExoticComponent<CopyButtonProps & React.RefAttributes<HTMLButtonElement>>;