@amsterdamdatalabs/enact-design-system 0.1.12 → 0.1.19

package/dist/components/ai/ProviderModelSelectorView/provider-model-selector-parts.d.ts

@@ -0,0 +1,39 @@
+import type { ReactElement, ReactNode } from "react";
+import type { ProviderModelSelectorLabels, ProviderModelSelectorModelListRenderArgs, ProviderModelSelectorModelRow, ProviderModelSelectorModelRowProps, ProviderModelSelectorProvider } from "./ProviderModelSelectorView";
+export declare function ModelRowFavoriteButton({ isFavorite, labels, onToggleFavorite, row, }: {
+    isFavorite: boolean;
+    labels: Pick<ProviderModelSelectorLabels, "favoriteModel" | "unfavoriteModel">;
+    onToggleFavorite?: (provider: string, modelId: string) => void;
+    row: ProviderModelSelectorModelRowProps["row"];
+}): ReactElement | null;
+export declare function ProviderModelSelectorEmptyState({ children, icon, status, }: {
+    children: ReactNode;
+    icon: ReactNode;
+    status?: boolean;
+}): ReactElement;
+export declare function ProviderModelSelectorProviderRows({ labels, onDrillDown, providers, renderProviderIcon, }: {
+    labels: ProviderModelSelectorLabels;
+    onDrillDown: (providerId: string, providerLabel: string) => void;
+    providers: readonly ProviderModelSelectorProvider[];
+    renderProviderIcon?: (providerId: string) => ReactNode;
+}): ReactElement;
+export declare function ProviderModelSelectorModelRows({ ModelRow, favoriteKeys, labels, onSelect, onToggleFavorite, renderModelList, renderProviderIcon, rows, searchQuery, selectedModel, selectedProvider, }: {
+    ModelRow: (props: ProviderModelSelectorModelRowProps) => ReactElement;
+    favoriteKeys: ReadonlySet<string>;
+    labels: ProviderModelSelectorLabels;
+    onSelect: (provider: string, modelId: string) => void;
+    onToggleFavorite?: (provider: string, modelId: string) => void;
+    renderModelList?: (args: ProviderModelSelectorModelListRenderArgs) => ReactNode;
+    renderProviderIcon?: (providerId: string) => ReactNode;
+    rows: readonly ProviderModelSelectorModelRow[];
+    searchQuery: string;
+    selectedModel: string;
+    selectedProvider: string;
+}): ReactNode;
+export declare function ProviderModelSelectorErrorState({ isRetryingProvider, labels, message, onRetryProvider, providerId, }: {
+    isRetryingProvider: boolean;
+    labels: ProviderModelSelectorLabels;
+    message: string;
+    onRetryProvider?: (providerId: string) => void;
+    providerId: string;
+}): ReactElement;

package/dist/components/ai/ProviderModelSelectorView/provider-model-selector-utils.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderModelSelectorModelRow as ProviderModelSelectorModelRowData } from "./ProviderModelSelectorView";
+export declare function sortProviderModelSelectorFavoritesFirst(rows: readonly ProviderModelSelectorModelRowData[], favoriteKeys: ReadonlySet<string>): readonly ProviderModelSelectorModelRowData[];

package/dist/components/ai/QueuedMessageList/QueuedMessageList.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface QueuedMessageItem {
+    id: number | string;
+    text: string;
+}
+export interface QueuedMessageListLabels {
+    disableQueueing?: string;
+    edit?: string;
+    more?: string;
+    remove?: string;
+    steer?: string;
+}
+export interface QueuedMessageListProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Ordered queue data. Empty queues render nothing. */
+    items: readonly QueuedMessageItem[];
+    /** Localizable action labels. */
+    labels?: QueuedMessageListLabels;
+    /** Emits a request to disable queued-message behaviour. */
+    onDisableQueueing?: () => void;
+    /** Emits an edit intent for a queue item. */
+    onEdit?: (id: QueuedMessageItem["id"]) => void;
+    /** Emits a removal intent for a queue item. */
+    onRemove?: (id: QueuedMessageItem["id"]) => void;
+    /** Emits an intent to send a queued item next. */
+    onSteer?: (id: QueuedMessageItem["id"]) => void;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled list of queued follow-up messages. It does not own queue state:
+ * consumers supply ordered items and persist the emitted edit/remove/steer
+ * intents in their own runtime layer.
+ */
+export declare function QueuedMessageList({ className, items, labels, onDisableQueueing, onEdit, onRemove, onSteer, ref, ...rest }: QueuedMessageListProps): import("react").JSX.Element | null;

package/dist/components/ai/QueuedMessageList/index.d.ts

@@ -0,0 +1 @@
+export { type QueuedMessageItem, QueuedMessageList, type QueuedMessageListLabels, type QueuedMessageListProps, } from "./QueuedMessageList";

package/dist/components/ai/ReasoningDisclosure/ReasoningDisclosure.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface ReasoningDisclosureProps extends Omit<HTMLAttributes<HTMLDetailsElement>, "children"> {
+    body: ReactNode;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    ref?: Ref<HTMLDetailsElement>;
+    summary: ReactNode;
+}
+export declare function ReasoningDisclosure({ body, className, defaultOpen, onOpenChange, open, ref, summary, ...rest }: ReasoningDisclosureProps): import("react").JSX.Element;

package/dist/components/ai/ReasoningDisclosure/index.d.ts

@@ -0,0 +1 @@
+export { ReasoningDisclosure, type ReasoningDisclosureProps, } from "./ReasoningDisclosure";

package/dist/components/ai/SessionImportSheet/SessionImportSheet.d.ts

@@ -0,0 +1,76 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import { type ResponsiveComboboxOption } from "../../forms/ResponsiveCombobox";
+export interface SessionImportFilter extends ResponsiveComboboxOption {
+    /** Optional app-normalized provider mark rendered next to the label. */
+    icon?: ReactNode;
+}
+export interface SessionImportItem {
+    /** Whether this and other rows cannot be selected. */
+    disabled?: boolean;
+    /** Optional app-normalized provider mark. */
+    icon?: ReactNode;
+    /** Stable identifier returned with the import intent. */
+    id: string;
+    /** Indicates that this item is the current import request. */
+    importing?: boolean;
+    /** Secondary timestamp or status text. */
+    meta?: string;
+    /** Optional workspace path. */
+    path?: string;
+    /** Session prompt or summary. */
+    preview?: string;
+    /** Primary session name. */
+    title: string;
+}
+export interface SessionImportSheetLabels {
+    /** Accessible provider-filter label. */
+    filter: string;
+    /** Row state displayed while its import intent is pending. */
+    importing: string;
+    /** Accessible refresh action label. */
+    refresh: string;
+}
+export interface SessionImportSheetProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSelect" | "title"> {
+    /** Text rendered when `emptyState` is active. */
+    emptyState?: ReactNode;
+    /** Enables the no-results presentation after app-level state evaluation. */
+    emptyStateVisible?: boolean;
+    /** App-normalized provider choices. One or fewer choices hide the filter. */
+    filters?: readonly SessionImportFilter[];
+    /** App-normalized selectable sessions. */
+    items?: readonly SessionImportItem[];
+    /** Localized labels for controlled actions and row states. */
+    labels: SessionImportSheetLabels;
+    /** Whether the initial data request is pending. */
+    loading?: boolean;
+    /** Optional sheet max-width; defaults to the original importer width. */
+    maxWidth?: number | string;
+    /** Status rows chosen by the application after runtime/query evaluation. */
+    messages?: readonly string[];
+    /** Requests dismissal from the close control, Escape, or backdrop. */
+    onClose: () => void;
+    /** Reports the chosen provider filter. */
+    onFilterChange?: (filterId: string) => void;
+    /** Reports an explicit session-import intent. */
+    onImport?: (itemId: string) => void;
+    /** Reports an explicit data-refresh intent. */
+    onRefresh?: () => void;
+    /** Controlled open state. */
+    open: boolean;
+    /** Whether the refresh request is currently pending. */
+    refreshing?: boolean;
+    /** The controlled provider-filter id. */
+    selectedFilterId?: string;
+    /** Optional stable identifier for the sheet and controls. */
+    testId?: string;
+    /** Optional stable identifier prefix for sheet controls and rows. */
+    testIdPrefix?: string;
+    /** Accessible sheet title. */
+    title: ReactNode;
+}
+/**
+ * Controlled recent-session importer presentation. The consuming application
+ * owns provider discovery, querying, persistence, and the import mutation;
+ * this component owns the sheet anatomy, filter UI, row states, and CSS.
+ */
+export declare function SessionImportSheet({ className, emptyState, emptyStateVisible, filters, items, labels, loading, maxWidth, messages, onClose, onFilterChange, onImport, onRefresh, open, refreshing, selectedFilterId, testId, testIdPrefix, title, ...rest }: SessionImportSheetProps): import("react").JSX.Element;

package/dist/components/ai/SessionImportSheet/index.d.ts

@@ -0,0 +1 @@
+export { type SessionImportFilter, type SessionImportItem, SessionImportSheet, type SessionImportSheetLabels, type SessionImportSheetProps, } from "./SessionImportSheet";

package/dist/components/ai/SkillCall/SkillCall.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type SkillCallStatus = "running" | "done" | "failed";
+export type SkillCallSource = "builtin" | "extension";
+export interface SkillCallProps extends HTMLAttributes<HTMLDivElement> {
+    ref?: Ref<HTMLDivElement>;
+    /** Result content rendered in the card body. */
+    result?: ReactNode;
+    /** Skill name displayed in the card header. */
+    skill: string;
+    /** Provenance: "extension" renders a provenance badge. */
+    source?: SkillCallSource;
+    /** Current execution state. */
+    status?: SkillCallStatus;
+}
+export declare function SkillCall({ skill, status, result, source, className, ref, ...rest }: SkillCallProps): import("react").JSX.Element;

package/dist/components/ai/SkillCall/index.d.ts

@@ -0,0 +1 @@
+export { SkillCall, type SkillCallProps, type SkillCallSource, type SkillCallStatus, } from "./SkillCall";

package/dist/components/ai/SubagentTrack/SubagentTrack.d.ts

@@ -0,0 +1,37 @@
+import type { DetailsHTMLAttributes, ReactNode, Ref } from "react";
+export interface SubagentTrackAction {
+    disabled?: boolean;
+    icon: ReactNode;
+    id: string;
+    label: string;
+    onSelect?: () => void;
+    testId?: string;
+}
+export interface SubagentTrackItem {
+    actions?: SubagentTrackAction[];
+    icon?: ReactNode;
+    id: string;
+    label: ReactNode;
+    onSelect?: () => void;
+    testId?: string;
+}
+export interface SubagentTrackProps extends Omit<DetailsHTMLAttributes<HTMLDetailsElement>, "children" | "open"> {
+    /** Open on first render when uncontrolled. */
+    defaultOpen?: boolean;
+    /** Normalized rows and row-level action intents. */
+    items: SubagentTrackItem[];
+    /** Called whenever the disclosure requests an open-state change. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled disclosure state. */
+    open?: boolean;
+    ref?: Ref<HTMLDetailsElement>;
+    /** Display-ready header summary. */
+    summary: ReactNode;
+    /** Stable prefix for root, header, row, and action test ids. */
+    testId?: string;
+}
+/**
+ * Controlled disclosure track for normalized subagent rows. The consumer owns
+ * agents, session state, and action effects; the DS owns the visual surface.
+ */
+export declare function SubagentTrack({ className, defaultOpen, items, onOpenChange, open, ref, summary, testId, ...rest }: SubagentTrackProps): import("react").JSX.Element;

package/dist/components/ai/SubagentTrack/index.d.ts

@@ -0,0 +1 @@
+export { SubagentTrack, type SubagentTrackAction, type SubagentTrackItem, type SubagentTrackProps, } from "./SubagentTrack";

package/dist/components/ai/TodoListDisclosure/TodoListDisclosure.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface TodoListDisclosureItem {
+    /** Whether the task has been completed. */
+    completed: boolean;
+    /** Stable identifier supplied by the consuming product. */
+    id: string;
+    /** Display-ready task text. */
+    label: string;
+}
+export interface TodoListDisclosureProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Open on first render when uncontrolled. Defaults to false. */
+    defaultOpen?: boolean;
+    /** Copy rendered when there are no tasks. */
+    emptyLabel?: string;
+    /** Normalized task items. */
+    items: TodoListDisclosureItem[];
+    /** Called after the requested disclosure state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled disclosure state. */
+    open?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    /** Summary title displayed in the trigger. */
+    title: string;
+}
+/**
+ * A controlled, presentational task-list disclosure. Consumers retain task
+ * sourcing, localization, and persistence while the design system owns the
+ * summary, completion treatment, and expandable list visuals.
+ */
+export declare function TodoListDisclosure({ className, defaultOpen, emptyLabel, items, onOpenChange, open, ref, title, ...rest }: TodoListDisclosureProps): import("react").JSX.Element;

package/dist/components/ai/TodoListDisclosure/index.d.ts

@@ -0,0 +1 @@
+export { TodoListDisclosure, type TodoListDisclosureItem, type TodoListDisclosureProps, } from "./TodoListDisclosure";

package/dist/components/ai/ToolCall/ToolCall.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ToolCallStatus = "running" | "done" | "failed";
+export type ToolCallMode = "business" | "advanced";
+export interface ToolCallProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Raw call arguments (rendered as structured view or JSON in advanced mode). */
+    args?: unknown;
+    /** Initial expanded state (uncontrolled). */
+    defaultOpen?: boolean;
+    /** Display mode: business shows a summary; advanced shows full args + output. */
+    mode?: ToolCallMode;
+    /** Tool name / call identifier shown in the header. */
+    name: string;
+    /** Output produced by the tool (rendered in the body). */
+    output?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    /** Indicates the current execution state. */
+    status?: ToolCallStatus;
+}
+export declare function ToolCall({ name, args, output, status, mode, defaultOpen, className, ref, ...rest }: ToolCallProps): import("react").JSX.Element;

package/dist/components/ai/ToolCall/index.d.ts

@@ -0,0 +1 @@
+export { ToolCall, type ToolCallMode, type ToolCallProps, type ToolCallStatus, } from "./ToolCall";

package/dist/components/ai/ToolCallDetailView/ToolCallDetailView.d.ts

@@ -0,0 +1,60 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type ToolOutputPanelLabels } from "../ToolOutputPanel/ToolOutputPanel";
+export type ToolCallDetailStatus = "canceled" | "completed" | "failed" | "running";
+export type ToolCallDetailSection = {
+    code: string;
+    copyable?: boolean;
+    fileName?: string;
+    id: string;
+    kind: "code";
+    label?: ReactNode;
+    language?: string;
+    showLineNumbers?: boolean;
+    startLineNumber?: number;
+    wrap?: boolean;
+} | {
+    fileName?: string;
+    id: string;
+    kind: "diff";
+    label?: ReactNode;
+    mode?: "split" | "unified";
+    newText: string;
+    oldText: string;
+} | {
+    errorText?: string;
+    id: string;
+    kind: "output";
+    labels?: ToolOutputPanelLabels;
+    openFilePath?: string;
+    output: string;
+    rawOutput?: string;
+    summary?: string;
+} | {
+    content: ReactNode;
+    id: string;
+    kind: "text";
+    label?: ReactNode;
+    tone?: "danger" | "muted" | "primary";
+};
+export interface ToolCallDetailViewProps extends Omit<HTMLAttributes<HTMLElement>, "children" | "title"> {
+    /** Localized accessible label for the optional close action. */
+    closeLabel?: string;
+    /** An optional leading visual supplied by the application. */
+    icon?: ReactNode;
+    /** Reports an application-owned close/dismiss intent. */
+    onClose?: () => void;
+    ref?: Ref<HTMLElement>;
+    /** Display-ready detail sections. Protocol parsing and syntax normalization stay in the app. */
+    sections: ToolCallDetailSection[];
+    /** Visual execution state supplied by the application. */
+    status?: ToolCallDetailStatus;
+    /** Localized display label for status; defaults to the normalized status. */
+    statusLabel?: ReactNode;
+    /** Application-provided title for the inspected tool call. */
+    title: ReactNode;
+}
+/**
+ * Presentation-only inspector for a normalized tool-call detail. The app
+ * retains protocol decoding, syntax/diff preparation, and sheet lifecycle.
+ */
+export declare function ToolCallDetailView({ className, closeLabel, icon, onClose, ref, sections, status, statusLabel, title, ...rest }: ToolCallDetailViewProps): import("react").JSX.Element;

package/dist/components/ai/ToolCallDetailView/index.d.ts

@@ -0,0 +1 @@
+export { type ToolCallDetailSection, type ToolCallDetailStatus, ToolCallDetailView, type ToolCallDetailViewProps, } from "./ToolCallDetailView";

package/dist/components/ai/ToolCallGroup/ToolCallGroup.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ToolCallGroupStatus = "canceled" | "completed" | "failed" | "running";
+export interface ToolCallGroupCall {
+    durationLabel?: string;
+    errorText?: string;
+    icon?: ReactNode;
+    id: string;
+    label?: string;
+    name: string;
+    openFilePath?: string;
+    output: string;
+    rawOutput?: string;
+    status?: ToolCallGroupStatus;
+    summary?: string;
+}
+export interface ToolCallGroupData {
+    calls: ToolCallGroupCall[];
+    id: string;
+    label?: string;
+    pluginIcon?: ReactNode;
+    pluginKey: string;
+    pluginLabel: string;
+}
+export interface ToolCallGroupProps extends Omit<HTMLAttributes<HTMLDetailsElement>, "children"> {
+    /** Normalized calls and integration metadata to render. */
+    group: ToolCallGroupData;
+    ref?: Ref<HTMLDetailsElement>;
+}
+/**
+ * Controlled visual disclosure for a consecutive group of tool calls.
+ * Consumers retain protocol decoding and pass only display-ready call data.
+ */
+export declare function ToolCallGroup({ className, group, ref, ...rest }: ToolCallGroupProps): import("react").JSX.Element;

package/dist/components/ai/ToolCallGroup/index.d.ts

@@ -0,0 +1 @@
+export { ToolCallGroup, type ToolCallGroupCall, type ToolCallGroupData, type ToolCallGroupProps, type ToolCallGroupStatus, } from "./ToolCallGroup";

package/dist/components/ai/ToolOutputPanel/ToolOutputPanel.d.ts

@@ -0,0 +1,26 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface ToolOutputPanelLabels {
+    raw?: string;
+    rendered?: string;
+}
+export interface ToolOutputPanelProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Error summary supplied by the application when the tool call fails. */
+    errorText?: string;
+    /** Optional localizable labels for the output toggle. */
+    labels?: ToolOutputPanelLabels;
+    /** Path opened or affected by the tool call. */
+    openFilePath?: string;
+    /** Normalized rendered output. */
+    output: string;
+    /** Raw output offered through the visual toggle when it differs from output. */
+    rawOutput?: string;
+    ref?: Ref<HTMLDivElement>;
+    /** Concise human-readable result summary. */
+    summary?: string;
+}
+/**
+ * Presentation-only output view for a tool invocation. Applications provide
+ * normalized text; the component owns the raw/rendered disclosure state and
+ * all output visual treatment.
+ */
+export declare function ToolOutputPanel({ className, errorText, labels, openFilePath, output, rawOutput, ref, summary, ...rest }: ToolOutputPanelProps): import("react").JSX.Element;

package/dist/components/ai/ToolOutputPanel/index.d.ts

@@ -0,0 +1 @@
+export { ToolOutputPanel, type ToolOutputPanelLabels, type ToolOutputPanelProps, } from "./ToolOutputPanel";

package/dist/components/ai/Transcript/Transcript.d.ts

@@ -0,0 +1,104 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import type { DiffHunk } from "../../content/DiffView/diff";
+import type { ActivitySummaryMetric } from "../ActivitySummary/ActivitySummary";
+import type { HookActivityTone } from "../HookActivity/HookActivity";
+import type { SkillCallSource, SkillCallStatus } from "../SkillCall/SkillCall";
+import type { ToolCallStatus } from "../ToolCall/ToolCall";
+export type TranscriptItem = {
+    kind: "user";
+    text: string;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "markdown";
+    markdown: string;
+} | {
+    kind: "reasoning";
+    text: string;
+} | {
+    kind: "code";
+    code: string;
+    language?: string;
+} | {
+    kind: "diff";
+    hunks: DiffHunk[];
+    fileName?: string;
+} | {
+    kind: "tool";
+    name: string;
+    args?: unknown;
+    output?: ReactNode;
+    status?: ToolCallStatus;
+} | {
+    kind: "hook";
+    event: string;
+    tone?: HookActivityTone;
+    detail?: ReactNode;
+} | {
+    kind: "skill";
+    skill: string;
+    status?: SkillCallStatus;
+    source?: SkillCallSource;
+    result?: ReactNode;
+} | {
+    kind: "activity";
+    summary: string;
+    metrics?: ActivitySummaryMetric[];
+    children?: ReactNode;
+} | {
+    kind: "artifact";
+    title: string;
+    body: ReactNode;
+} | {
+    kind: "copilot_insight";
+    title: string;
+    body: string;
+    source?: string;
+} | {
+    kind: "copilot_recommend";
+    title: string;
+    body: string;
+    productFamily?: string;
+} | {
+    kind: "copilot_evidence";
+    quote: string;
+    source: string;
+} | {
+    kind: "copilot_questions";
+    items: string[];
+} | {
+    kind: "copilot_action";
+    text: string;
+};
+export type TranscriptMode = "business" | "advanced";
+export interface TranscriptProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Heterogeneous list of transcript turns/events. */
+    items: TranscriptItem[];
+    /** Display mode. Business hides reasoning and collapses tool internals. Defaults to "business". */
+    mode?: TranscriptMode;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Transcript({ items, mode, className, ref, ...rest }: TranscriptProps): import("react").JSX.Element;
+/** Shape of a rollout envelope event. */
+export interface RolloutEnvelope {
+    payload: unknown;
+    timestamp: string;
+    type: "session_meta" | "event_msg" | "response_item" | "turn_context";
+}
+/**
+ * Maps a flat array of rollout envelope events to `TranscriptItem[]`.
+ *
+ * Pairing: function_call + function_call_output are matched by call_id;
+ * the output is attached as a string to the tool item.
+ *
+ * Intentionally dropped (metadata, not renderable):
+ *   - session_meta envelopes
+ *   - turn_context envelopes
+ *   - event_msg/task_started, event_msg/task_complete, event_msg/token_count
+ *   - response_item/message with role="developer" (system instructions)
+ *   - response_item/message with role="user" (covered by event_msg/user_message)
+ *   - response_item/message with role="assistant" (covered by event_msg/agent_message)
+ *   - response_item/message content items that are input_image or empty
+ */
+export declare function fromRollout(events: RolloutEnvelope[]): TranscriptItem[];

package/dist/components/ai/Transcript/index.d.ts

@@ -0,0 +1 @@
+export { fromRollout, type RolloutEnvelope, Transcript, type TranscriptItem, type TranscriptMode, type TranscriptProps, } from "./Transcript";

package/dist/components/ai/TranscriptAttachmentCard/TranscriptAttachmentCard.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface TranscriptAttachmentCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    /** Indicates whether optional actions are currently unavailable. */
+    disabled?: boolean;
+    /** Localized accessible label for the download action. */
+    downloadLabel?: string;
+    /** Small extension mark displayed in the leading file tile. */
+    extension: ReactNode;
+    /** Normalized file kind, such as Document or Spreadsheet. */
+    kind: ReactNode;
+    /** Primary artifact name. */
+    name: ReactNode;
+    /** Reports an app-owned download intent. */
+    onDownload?: () => void;
+    /** Reports an app-owned open/preview intent. */
+    onOpen?: () => void;
+    /** Localized accessible label for the open action. */
+    openAriaLabel?: string;
+    /** Localized visible label for the open action. */
+    openLabel?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled transcript attachment presentation. Consumers resolve artifact
+ * metadata, URLs, navigation, and download behaviour; the design system owns
+ * the shared metadata-card anatomy and optional action affordances.
+ */
+export declare function TranscriptAttachmentCard({ className, disabled, downloadLabel, extension, kind, name, onDownload, onOpen, openAriaLabel, openLabel, ref, ...rest }: TranscriptAttachmentCardProps): import("react").JSX.Element;

package/dist/components/ai/TranscriptAttachmentCard/index.d.ts

@@ -0,0 +1 @@
+export { TranscriptAttachmentCard, type TranscriptAttachmentCardProps, } from "./TranscriptAttachmentCard";

package/dist/components/ai/TranscriptMessageFooter/TranscriptMessageFooter.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type ActionChoicePopoverOption } from "../../overlay/ActionChoicePopover";
+export interface TranscriptMessageFooterAction {
+    disabled?: boolean;
+    href?: string;
+    icon?: ReactNode;
+    id: string;
+    label: ReactNode;
+    onSelect?: () => Promise<void> | void;
+    testId?: string;
+}
+export interface TranscriptMessageFooterMenu {
+    actions: ActionChoicePopoverOption[];
+    onSelect: (id: string) => Promise<void> | void;
+    placement?: "bottom-end" | "bottom-start" | "top-end" | "top-start";
+    testId?: string;
+    triggerLabel: string;
+    triggerVisual: ReactNode;
+}
+export interface TranscriptMessageFooterProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    actions?: TranscriptMessageFooterAction[];
+    alternateTimestamp?: ReactNode;
+    leading?: ReactNode;
+    menu?: TranscriptMessageFooterMenu;
+    ref?: Ref<HTMLDivElement>;
+    timestamp: ReactNode;
+    timestampAriaLabel?: string;
+    variant?: "default" | "turn";
+}
+/** Controlled transcript footer for normalized labeled actions and timestamp copy. */
+export declare function TranscriptMessageFooter({ alternateTimestamp, actions, className, leading, menu, ref, timestamp, timestampAriaLabel, variant, ...rest }: TranscriptMessageFooterProps): import("react").JSX.Element;

package/dist/components/ai/TranscriptMessageFooter/index.d.ts

@@ -0,0 +1 @@
+export { TranscriptMessageFooter, type TranscriptMessageFooterAction, type TranscriptMessageFooterMenu, type TranscriptMessageFooterProps, } from "./TranscriptMessageFooter";

package/dist/components/ai/TranscriptPeek/TranscriptPeek.d.ts

@@ -0,0 +1,23 @@
+import type { HTMLAttributes, Ref } from "react";
+import { type TranscriptItem, type TranscriptMode } from "../Transcript";
+export interface TranscriptPeekProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Open on first render when uncontrolled. */
+    defaultOpen?: boolean;
+    /** Transcript events; the latest event is shown when expanded. */
+    items: TranscriptItem[];
+    /** Header shown above the latest transcript item. */
+    label?: string;
+    /** Called after the disclosure state changes. */
+    onOpenChange?: (open: boolean) => void;
+    /** Controlled disclosure state. */
+    open?: boolean;
+    ref?: Ref<HTMLDivElement>;
+    /** Display mode passed to the transcript renderer. */
+    transcriptMode?: TranscriptMode;
+}
+/**
+ * A compact disclosure for the latest transcript event. It intentionally owns
+ * only presentational disclosure state; consumers retain transcript sourcing
+ * and surrounding card chrome.
+ */
+export declare function TranscriptPeek({ className, defaultOpen, items, label, onOpenChange, open, ref, transcriptMode, ...rest }: TranscriptPeekProps): import("react").JSX.Element | null;

package/dist/components/ai/TranscriptPeek/index.d.ts

@@ -0,0 +1 @@
+export { TranscriptPeek, type TranscriptPeekProps } from "./TranscriptPeek";