@50arms/ui 0.0.0-stage → 35.2.0

package/dist/types/components/chat/Attachment.d.ts

@@ -0,0 +1,125 @@
+import { type ComponentProps, type ReactNode, type Ref } from "react";
+import type { ChatFile } from "./types";
+import type { IconName } from "../Icon";
+export declare function TileMedia({ file, iconSize, className }: {
+    file: ChatFile;
+    iconSize: "sm" | "lg";
+    className?: string;
+}): import("react").JSX.Element;
+export type AttachmentLayout = "tile" | "row" | "strip";
+export interface AttachmentProps {
+    file: ChatFile;
+    layout?: AttachmentLayout;
+    /** Overrides the size line — "Sheet 2 of 4", a page count, anything truer. */
+    meta?: ReactNode;
+    /**
+     * The consumer's own control, rendered first in the action cluster — "Extract
+     * this", "Attach to the demand", "Cancel the upload".
+     *
+     * A SLOT RATHER THAN ANOTHER BOOLEAN, because the library has no opinion
+     * about what the verb is and a fixed list would be wrong for the second
+     * consumer and every one after. Remove, preview and download stay separate
+     * props: they are the three actions an attachment has REGARDLESS of the
+     * application, and each carries its own rule about when it may appear.
+     *
+     * NO RULE IS IMPOSED ON THIS ONE. Download hides itself while a file is still
+     * uploading, because there is nothing complete to fetch; the consumer's action
+     * may well BE "cancel this upload", so it is rendered whatever the file's
+     * state, and the consumer decides whether their verb makes sense yet.
+     *
+     * It goes inside the cluster, above the full-card preview trigger — rendered
+     * anywhere else it would sit UNDER that trigger and never receive a click.
+     * Keep it to a control or two: this is a corner of a tile, not a menu bar.
+     *
+     * FILL IT WITH `AttachmentAction`, which is exported for exactly this. The
+     * built-in download and remove are that component, so anything else lands in
+     * the cluster at a different size and, on a tile, without the hover fade the
+     * two beside it have. Any node is accepted — the slot has no opinion — but
+     * "matches the built-ins" is a real requirement and there is no way to hit it
+     * by hand. Pass `tinted` when the tile has a picture behind the cluster: a
+     * `"tile"`, or a `"strip"` image tile (a strip tile for a non-image file is
+     * a plain card, so it is not tinted).
+     */
+    action?: ReactNode;
+    /**
+     * DXUI-74: a `"strip"` picture tile prints the file's name along its bottom edge. Off by default: the composer's
+     * strip shows a picture alone. A strip file card always shows its name.
+     */
+    caption?: boolean;
+    onRemove?: (file: ChatFile) => void;
+    onPreview?: (file: ChatFile) => void;
+    onDownload?: (file: ChatFile) => void;
+    /** Marks the file as the current selection in a gallery. */
+    selected?: boolean;
+    disabled?: boolean;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Attachment({ file, layout, meta, action, caption, onRemove, onPreview, onDownload, selected, disabled, className, ref, }: AttachmentProps): import("react").JSX.Element;
+export interface AttachmentActionProps extends Omit<ComponentProps<"button">, "children" | "className" | "type" | "aria-label" | "onClick" | "disabled"> {
+    icon: IconName;
+    /** The accessible name AND the tooltip. Include the file: "Extract report.pdf". */
+    label: string;
+    /** Omitted when the control is the trigger of a `Menu`, which supplies the press itself. */
+    onClick?: () => void;
+    disabled?: boolean;
+    /**
+     * On a tile the buttons sit over imagery, so they need their own ground —
+     * and they FADE IN on hover rather than sitting permanently over the picture.
+     * A device with no hover at all (`(hover: none)`, a phone or tablet) has
+     * nothing to fade them in with, so there they are visible at rest (DX-4039);
+     * keyboard focus still reveals them on a hover-capable one.
+     *
+     * Pass it when the control sits over a picture: a `"tile"`, or a `"strip"`
+     * image tile. Getting it wrong is not a style preference: a tinted control on
+     * a row (or a strip file card) is dark-on-dark, and an untinted one over a
+     * photograph is a grey glyph on an arbitrary background.
+     */
+    tinted?: boolean;
+}
+/**
+ * One control in an attachment's action cluster.
+ *
+ * THE CONTROL `Attachment.action` IS MEANT TO BE FILLED WITH, and until now it
+ * was module-private — so the slot existed with nothing in the library that
+ * fits it. A consumer's own `IconButton` is a different size and a different
+ * resting state, and on a tile it does not fade in on `group-hover/attachment`
+ * with the built-in download and remove beside it, so the one control the
+ * consumer added was the one that looked wrong.
+ *
+ * It is deliberately NOT `IconButton`: `size-6` rather than a control height,
+ * no ripple, no `disabledReason`, and a tinted variant that only means anything
+ * inside `.group/attachment`. That is a corner-of-a-tile control, not a general
+ * one, and generalising it would give the cluster two different buttons again.
+ *
+ *   <Attachment
+ *     file={file}
+ *     layout="tile"
+ *     action={<AttachmentAction icon="sparkles" label={`Extract ${file.name}`}
+ *                               onClick={() => extract(file)} tinted />}
+ *   />
+ */
+export declare function AttachmentAction({ icon, label, onClick, disabled, tinted, ...rest }: AttachmentActionProps): import("react").JSX.Element;
+export interface AttachmentListProps {
+    files: ChatFile[];
+    layout?: AttachmentLayout;
+    /**
+     * `Attachment.action`, per file — a FUNCTION rather than a node, because the
+     * control almost always has to know which file it is on.
+     *
+     * Without it the slot would exist only on a lone `Attachment`, and a consumer
+     * wanting one on a list would have to stop using the list — which is the
+     * rebuild this slot was added to prevent, one level up.
+     */
+    action?: (file: ChatFile) => ReactNode;
+    /** `Attachment.caption` for every file. */
+    caption?: boolean;
+    onRemove?: (file: ChatFile) => void;
+    onPreview?: (file: ChatFile) => void;
+    onDownload?: (file: ChatFile) => void;
+    /** Collapses to "+N more" past this count. Ignored by `layout="strip"`, which scrolls instead. */
+    max?: number;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function AttachmentList({ files, layout, action, caption, onRemove, onPreview, onDownload, max, disabled, className, }: AttachmentListProps): import("react").JSX.Element | null;

package/dist/types/components/chat/Chat.d.ts

@@ -0,0 +1,60 @@
+import { type ReactNode } from "react";
+import { type ComposerProps } from "./Composer";
+import { type MessageAction } from "./Message";
+import { ModelSelector, type ChatModel } from "./ModelSelector";
+import { type EffortLevel } from "./EffortControl";
+import { type ContextSegment, type UsageLimit } from "./ContextMeter";
+import type { ChatComponents, ChatMessage, PartRenderers } from "./types";
+export type ChatSurface = "inline" | "sidebar" | "popover";
+export interface ChatProps<TApp = unknown> extends Pick<ComposerProps, "value" | "onValueChange" | "onSubmit" | "files" | "onFilesAdded" | "onFileRemoved" | "busy" | "onStop" | "placeholder" | "disabled" | "error" | "accept" | "uploadImage"> {
+    messages: ChatMessage[];
+    /** Replaces a built-in part renderer. Partial — override one, keep the rest. */
+    renderers?: PartRenderers<TApp>;
+    /** Application components a message may address by name. */
+    components?: ChatComponents<TApp>;
+    /** Handed to every renderer at call time, so a module-scope registry still
+        reaches live application state. */
+    appContext?: TApp;
+    title?: ReactNode;
+    subtitle?: ReactNode;
+    /** Buttons in the header — new thread, settings, close. */
+    headerActions?: ReactNode;
+    /** Shown instead of the transcript when there are no messages. */
+    empty?: ReactNode;
+    models?: ChatModel[];
+    model?: string;
+    onModelChange?: (id: string) => void;
+    /** Switches under the model list — fast mode, thinking, and so on. */
+    modelOptions?: Parameters<typeof ModelSelector>[0]["options"];
+    effortLevels?: EffortLevel[];
+    effort?: string;
+    onEffortChange?: (id: string) => void;
+    context?: {
+        segments: ContextSegment[];
+        capacity: number;
+        limits?: UsageLimit[];
+    };
+    /** Per-message buttons. Copy is always present and is not listed here. */
+    messageActions?: MessageAction[];
+    showTimestamps?: boolean;
+    /** Status line above the composer — "Thinking…", "Running tests". */
+    status?: ReactNode;
+    hint?: ReactNode;
+    surface?: ChatSurface;
+    className?: string;
+}
+export declare function Chat<TApp = unknown>({ messages, renderers, components, appContext, title, subtitle, headerActions, empty, models, model, onModelChange, modelOptions, effortLevels, effort, onEffortChange, context, messageActions, showTimestamps, status, hint, surface, className, ...composer }: ChatProps<TApp>): import("react").JSX.Element;
+export interface ChatPopoverProps<TApp = unknown> extends ChatProps<TApp> {
+    /** The control that opens it. Defaults to a floating round button. */
+    trigger?: ReactNode;
+    side?: "top" | "bottom" | "left" | "right";
+    align?: "start" | "center" | "end";
+}
+/**
+ * The same chat, anchored to a trigger.
+ *
+ * A popover rather than a fixed-position widget: anchoring is the positioning
+ * engine's job, and a hand-placed `bottom-6 right-6` panel is the version that
+ * ends up off screen on a short viewport or under a cookie banner.
+ */
+export declare function ChatPopover<TApp = unknown>({ trigger, side, align, ...chat }: ChatPopoverProps<TApp>): import("react").JSX.Element;

package/dist/types/components/chat/Composer.d.ts

@@ -0,0 +1,62 @@
+import { type ReactNode, type Ref } from "react";
+import { type MarkdownEditorHandle } from "../MarkdownEditor";
+import type { ImageUploader } from "../../lib/markdown/image-pipeline";
+import type { ChatFile } from "./types";
+export interface ComposerProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    onSubmit: (value: string, files: ChatFile[]) => void;
+    /** Staged files, shown above the text. */
+    files?: ChatFile[];
+    onFilesAdded?: (files: File[]) => void;
+    onFileRemoved?: (file: ChatFile) => void;
+    /**
+     * DXUI-18: `"stacked"` (default) draws the text with its controls in a row UNDER it. `"inline"` draws ONE line,
+     * `[attach] [text that grows] [send]`, the staged files in a scrolling `AttachmentList layout="strip"` above the
+     * text, and `toolbar` / `hint` in a row under the box.
+     */
+    layout?: "stacked" | "inline";
+    /**
+     * DXUI-18: `"enter"` (default) sends on Enter and breaks the line on Shift+Enter. `"mod-enter"` sends on
+     * Ctrl/Cmd+Enter only; a plain Enter inserts a new line.
+     */
+    submitOn?: "enter" | "mod-enter";
+    /**
+     * DXUI-18: set → sending is unavailable AND this says why. The send button is disabled with the sentence as its
+     * tooltip and accessible description, and the keyboard send does nothing. Unset → only the built-in rules apply
+     * (empty, a file still uploading, busy, `disabled`).
+     */
+    submitDisabledReason?: string;
+    /** Streaming — the send button becomes stop. */
+    busy?: boolean;
+    onStop?: () => void;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Blocks submit and explains why, under the field. */
+    error?: ReactNode;
+    /** Controls at the bottom-left — model, effort, context, whatever applies. */
+    toolbar?: ReactNode;
+    /** Extra buttons beside the attach button. */
+    leading?: ReactNode;
+    /** Hint at bottom-right, left of the send button. With `layout="inline"` it joins `toolbar` in the row under the box,
+        which is where a caller's status line (a sending spinner, a note) goes. */
+    hint?: ReactNode;
+    accept?: string;
+    maxRows?: number;
+    /**
+     * DXUI-25: stores an image the text embeds (the attach chord, or a paste with no `onFilesAdded`) and resolves with its
+     * URL; overrides the nearest `MarkdownImageUploadProvider`. A file pasted or dropped WITH `onFilesAdded` is staged as an
+     * attachment instead and never reaches this. While an embedded file is not stored the send is unavailable.
+     */
+    uploadImage?: ImageUploader;
+    /** DXUI-74: stores any other file the text embeds as a link, with `uploadImage`'s contract; see `MarkdownEditorProps.uploadFile`. Leaving it out does NOT disable file uploads: the editor falls through to the nearest `MarkdownImageUploadProvider`. A viewer who cannot comment is given an uploader that refuses, as `CommentComposer` does. Set `isFileUrl` with it. */
+    uploadFile?: ImageUploader;
+    /** DXUI-74: the picture types `uploadImage` stores; see `MarkdownEditorProps.imageTypes`. */
+    imageTypes?: readonly string[];
+    /** DXUI-74: whether a link's destination is a stored file, so it gets a tile; see `MarkdownEditorProps.isFileUrl`. */
+    isFileUrl?: (url: string) => boolean;
+    className?: string;
+    /** DXUI-25: focuses the text (`focus("end")` puts the caret after the draft). */
+    ref?: Ref<MarkdownEditorHandle>;
+}
+export declare function Composer({ value, onValueChange, onSubmit, layout, submitOn, submitDisabledReason, files, onFilesAdded, onFileRemoved, busy, onStop, placeholder, disabled, error, toolbar, leading, hint, accept, maxRows, uploadImage, uploadFile, imageTypes, isFileUrl, className, ref, }: ComposerProps): import("react").JSX.Element;

package/dist/types/components/chat/ContextMeter.d.ts

@@ -0,0 +1,45 @@
+import { type ReactNode } from "react";
+export interface ContextSegment {
+    id: string;
+    label: string;
+    tokens: number;
+    /** Any CSS colour. Defaults walk a fixed palette in declaration order. */
+    color?: string;
+}
+export interface UsageLimit {
+    id: string;
+    label: string;
+    /** 0–100. */
+    percent: number;
+    /** "Resets in 1 hr 46 min" — relative or absolute, whichever is clearer. */
+    resets?: string;
+}
+export interface ContextMeterProps {
+    segments: ContextSegment[];
+    /** Total window size in tokens. */
+    capacity: number;
+    /** Plan or rate limits, listed under the breakdown. */
+    limits?: UsageLimit[];
+    /** Fraction of capacity at which the bar turns amber, then red. */
+    warnAt?: number;
+    dangerAt?: number;
+    /** Renders the panel inline rather than behind a trigger row. */
+    inline?: boolean;
+    side?: "top" | "bottom";
+    align?: "start" | "center" | "end";
+    className?: string;
+}
+export declare function ContextMeter({ segments, capacity, limits, warnAt, dangerAt, inline, side, align, className, }: ContextMeterProps): import("react").JSX.Element;
+/**
+ * A live status line for the composer — "Thinking…", "Ran 3 commands".
+ *
+ * Shimmer rather than a spinner: a spinner beside text competes with it for
+ * attention and adds a second thing moving in a row that already has one. The
+ * text saying what is happening IS the indicator.
+ */
+export interface ChatStatusProps {
+    children: ReactNode;
+    active?: boolean;
+    className?: string;
+}
+export declare function ChatStatus({ children, active, className }: ChatStatusProps): import("react").JSX.Element;

package/dist/types/components/chat/EffortControl.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode } from "react";
+export interface EffortLevel {
+    id: string;
+    /** "High" — appears on the trigger and above the slider. */
+    label: string;
+    /** One line explaining the trade at this stop. */
+    description?: ReactNode;
+}
+export interface EffortControlProps {
+    /** The scale, lowest first. @default the built-in five-step scale */
+    levels?: EffortLevel[];
+    value: string;
+    onValueChange: (id: string) => void;
+    /** Explains the whole control, behind the header's help affordance. */
+    help?: ReactNode;
+    /** Renders the slider inline instead of behind a trigger button. */
+    inline?: boolean;
+    side?: "top" | "bottom";
+    align?: "start" | "center" | "end";
+    disabled?: boolean;
+    className?: string;
+}
+export declare function EffortControl({ levels: levelsProp, value, onValueChange, help, inline, side, align, disabled, className, }: EffortControlProps): import("react").JSX.Element;

package/dist/types/components/chat/FileCover.d.ts

@@ -0,0 +1,14 @@
+import { type Ref } from "react";
+import type { ChatFile } from "./types";
+export interface FileCoverProps {
+    file: ChatFile;
+    /** CSS `aspect-ratio` of the box. */
+    aspect?: number | string;
+    /** Alt text of an image cover. Defaults to the file name. */
+    alt?: string;
+    /** Offered by a video's can't-play fallback. */
+    onDownload?: (file: ChatFile) => void;
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function FileCover({ file, aspect, alt, onDownload, className, ref, }: FileCoverProps): import("react").JSX.Element;

package/dist/types/components/chat/Message.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode, type Ref } from "react";
+import { Icon } from "../Icon";
+import type { ChatComponents, ChatFile, ChatMessage, MessagePart, PartRenderers, RenderContext, ToolPart } from "./types";
+export interface ToolCallProps {
+    part: ToolPart;
+    defaultOpen?: boolean;
+    className?: string;
+}
+/**
+ * A tool invocation, collapsed to one line.
+ *
+ * COLLAPSED BY DEFAULT because the transcript is a conversation and not a log:
+ * twenty lines of output between two sentences buries both of them. The summary
+ * carries enough to decide whether opening it is worth doing, which is the only
+ * decision anyone makes about a tool call they did not have to authorise.
+ */
+export declare function ToolCall({ part, defaultOpen, className }: ToolCallProps): import("react").JSX.Element;
+export interface MessagePartViewProps<TApp = unknown> {
+    part: MessagePart;
+    context: RenderContext<TApp>;
+    renderers?: PartRenderers<TApp>;
+    components?: ChatComponents<TApp>;
+    onPreviewFile?: (file: ChatFile) => void;
+    onDownloadFile?: (file: ChatFile) => void;
+}
+export declare function MessagePartView<TApp>({ part, context, renderers, components, onPreviewFile, onDownloadFile, }: MessagePartViewProps<TApp>): import("react").JSX.Element;
+export interface MessageAction {
+    id: string;
+    icon: Parameters<typeof Icon>[0]["name"];
+    label: string;
+    onClick: (message: ChatMessage) => void;
+    /** Latches on — a cast feedback vote, a saved message. */
+    active?: boolean;
+}
+export interface MessageProps<TApp = unknown> {
+    message: ChatMessage;
+    renderers?: PartRenderers<TApp>;
+    components?: ChatComponents<TApp>;
+    appContext?: TApp;
+    /** Buttons in the meta bar on the avatar and name line, after copy. Assistant turns only, unless `on` says otherwise. */
+    actions?: MessageAction[];
+    /**
+     * DXUI-19: the message's state (a person's Sent / Seen / Responded checks, a sending spinner), drawn in the
+     * meta bar after the time and copy. The library draws no state of its own; the caller owns what it means and
+     * supplies its accessible label. Always visible, never faded with the copy button.
+     */
+    state?: ReactNode;
+    /**
+     * DXUI-24: plain gray text for the meta bar (a size, a count), drawn directly after the time, before copy and
+     * `actions`, and never faded. Only a value that renders counts, as `state`. The caller owns what it says.
+     */
+    meta?: ReactNode;
+    /** Hides the avatar and name and tightens the spacing — for consecutive turns from the same author. The header line stays for the meta bar, on the author's side (left for an agent, right for a person). */
+    grouped?: boolean;
+    showAvatar?: boolean;
+    /** DX-5275: draws the author's avatar beside a `user` turn too (right edge), so a two-sided conversation of named people shows who spoke on both sides. */
+    showUserAvatar?: boolean;
+    showTimestamp?: boolean;
+    /** DX-5275: the time, the copy button and `actions` in the meta bar stay fully visible instead of fading in on hover, for a transcript whose age is part of the record. */
+    persistentToolbar?: boolean;
+    onPreviewFile?: (file: ChatFile) => void;
+    onDownloadFile?: (file: ChatFile) => void;
+    className?: string;
+    ref?: Ref<HTMLElement>;
+}
+export declare function Message<TApp = unknown>({ message, renderers, components, appContext, actions, state, meta, grouped, showAvatar, showUserAvatar, showTimestamp, persistentToolbar, onPreviewFile, onDownloadFile, className, ref, }: MessageProps<TApp>): import("react").JSX.Element;

package/dist/types/components/chat/MessageScroller.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode, type Ref } from "react";
+export interface MessageScrollerProps {
+    children: ReactNode;
+    /** Distance from the bottom, in px, still counted as "at the bottom". */
+    threshold?: number;
+    /** Label for the return-to-newest button. @default the built-in "Jump to latest" */
+    jumpLabel?: string;
+    /** Fades content at an edge only while more content lies past it (DX-5438): the top fade once scrolled down, the bottom fade while there is more below. */
+    fade?: boolean;
+    /**
+     * Where the newest content is (DX-5438). `bottom` (default) is a chat: the view starts at, and follows, the bottom, with a return button once the reader
+     * scrolls up. `top` is a newest-first list: the view starts at the top and never moves by itself. Set once per mount: to change it, remount the scroller (a `key`).
+     */
+    anchor?: "bottom" | "top";
+    className?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function MessageScroller({ children, threshold, jumpLabel, fade, anchor, className, ref, }: MessageScrollerProps): import("react").JSX.Element;

package/dist/types/components/chat/ModelSelector.d.ts

@@ -0,0 +1,44 @@
+import { type ReactNode } from "react";
+export interface ChatModel {
+    id: string;
+    name: string;
+    /** One line under the name — what this model is FOR. */
+    description?: string;
+    /** "New", "Fastest", a context size — anything that fits in a chip. */
+    badge?: ReactNode;
+    disabled?: boolean;
+    /**
+     * Keeps the model out of the main list until "More models" is opened.
+     *
+     * The primary list should be short enough to read at a glance; everything
+     * an experienced user occasionally reaches for lives one click deeper. A
+     * flat list of fifteen models makes the three that matter harder to find.
+     */
+    secondary?: boolean;
+}
+export interface ModelSelectorProps {
+    models: ChatModel[];
+    value: string;
+    onValueChange: (id: string) => void;
+    /** Extra switches under a separator — fast mode, thinking, whatever applies. */
+    options?: Array<{
+        id: string;
+        label: ReactNode;
+        description?: ReactNode;
+        checked: boolean;
+        onCheckedChange: (checked: boolean) => void;
+        disabled?: boolean;
+    }>;
+    /**
+     * Number keys pick from the primary list while the menu is open.
+     *
+     * Only while OPEN — a bare digit is a legitimate character everywhere else,
+     * and a chat's composer is the last place to steal one.
+     */
+    numericShortcuts?: boolean;
+    side?: "top" | "bottom";
+    align?: "start" | "center" | "end";
+    disabled?: boolean;
+    className?: string;
+}
+export declare function ModelSelector({ models, value, onValueChange, options, numericShortcuts, side, align, disabled, className, }: ModelSelectorProps): import("react").JSX.Element;

package/dist/types/components/chat/StreamingMarkdown.d.ts

@@ -0,0 +1,11 @@
+import { type MarkdownProps } from "../Markdown";
+export interface StreamingMarkdownProps extends Omit<MarkdownProps, "children"> {
+    children: string;
+}
+/**
+ * Blocks are memoised individually by `MarkdownNodes`' own reconciliation —
+ * see `Markdown`. What THIS wrapper adds is memoising the balance pass itself,
+ * so a re-render that does not change `children` (a sibling state update
+ * elsewhere in the message list) never re-scans the text.
+ */
+export declare const StreamingMarkdown: import("react").NamedExoticComponent<StreamingMarkdownProps>;

package/dist/types/components/chat/download-file.d.ts

@@ -0,0 +1,7 @@
+import type { ChatFile } from "./types";
+/**
+ * Saves a file through the browser: a throwaway anchor pointing at its `url`, named by its own file name when it has
+ * one (a stored PDF's `name` is a reference like "PDF 2", its `fileName` is what it is called on disk). A file with
+ * no `url` has nothing to fetch and does nothing.
+ */
+export declare function downloadChatFile(file: ChatFile): void;

package/dist/types/components/chat/file-icon.d.ts

@@ -0,0 +1,29 @@
+import type { IconName } from "../Icon";
+import type { ChatFile } from "./types";
+/** What a file is, before anyone decides what it looks like. */
+export type FileKind = "image" | "video" | "audio" | "code" | "text" | "archive" | "table" | "file";
+/** `fileName` is the file's own name when `name` is a label that is not (a markdown reference such as "PDF 2"): the extension is read from it. */
+export type FileIdentity = Pick<ChatFile, "name" | "mimeType" | "fileName">;
+/**
+ * What a file is, from its mime type and, when that says nothing, its
+ * extension.
+ *
+ * No mime type is normal — a file dragged from some sources arrives without
+ * one, and chat integrations send `application/octet-stream` for everything.
+ * The extension is the next best signal, and guessing from it beats a generic
+ * icon for the formats people actually attach.
+ */
+export declare function fileKindOf(file: FileIdentity): FileKind;
+/** What a file is called in a reference: a `FileKind`, with a PDF its own word (DXUI-74). */
+export type ReferenceKind = FileKind | "pdf";
+/**
+ * The kind a markdown reference to a file is named after ("Image 1", "PDF 2"). A PDF is a document to the
+ * icon table but is its own word in a reference; every other file is its `fileKindOf`.
+ */
+export declare function referenceKindOf(file: FileIdentity): ReferenceKind;
+/** The icon a kind of file wears when it has no picture. */
+export declare const fileKindIcon: (kind: FileKind) => IconName;
+/** The icon for a file. */
+export declare const fileIconFor: (file: FileIdentity) => IconName;
+export declare const isImageFile: (file: FileIdentity) => boolean;
+export declare const isVideoFile: (file: FileIdentity) => boolean;