@amsterdamdatalabs/enact-design-system 0.1.12 → 0.1.19

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

@@ -0,0 +1,51 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ConversationContextStepStatus = "done" | "failed" | "pending" | "running";
+export interface ConversationContextStep {
+    id: string;
+    label: string;
+    status?: ConversationContextStepStatus;
+}
+export interface ConversationContextOutput {
+    icon?: ReactNode;
+    id: string;
+    meta?: ReactNode;
+    title: ReactNode;
+}
+export interface ConversationContextFolder {
+    icon?: ReactNode;
+    id: string;
+    label: ReactNode;
+}
+export interface ConversationContextSource {
+    icon?: ReactNode;
+    id: string;
+    label: ReactNode;
+}
+export interface ConversationContextPanelLabels {
+    context?: string;
+    folders?: string;
+    outputs?: string;
+    progress?: string;
+}
+export interface ConversationContextPanelProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    folders?: ConversationContextFolder[];
+    labels?: ConversationContextPanelLabels;
+    /** Required controlled disclosure callback. */
+    onOpenChange: (open: boolean) => void;
+    /** Called after the panel reports close intent for a selected output. */
+    onOutputSelect?: (id: string) => void;
+    /** Required controlled disclosure state. */
+    open: boolean;
+    outputs?: ConversationContextOutput[];
+    ref?: Ref<HTMLDivElement>;
+    sources?: ConversationContextSource[];
+    steps?: ConversationContextStep[];
+    testId?: string;
+    triggerLabel?: string;
+}
+/**
+ * Controlled conversation task context. Consumers normalize task state and own
+ * output navigation; this component owns the disclosure, visual grouping and
+ * interaction states.
+ */
+export declare function ConversationContextPanel({ className, folders, labels, onOpenChange, onOutputSelect, open, outputs, ref, sources, steps, testId, triggerLabel, ...rest }: ConversationContextPanelProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { type ConversationContextFolder, type ConversationContextOutput, ConversationContextPanel, type ConversationContextPanelLabels, type ConversationContextPanelProps, type ConversationContextSource, type ConversationContextStep, type ConversationContextStepStatus, } from "./ConversationContextPanel";

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

@@ -0,0 +1,38 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ConversationMessageRole = "activity" | "assistant" | "system" | "user";
+export type ConversationMessageTone = "default" | "danger" | "muted" | "success" | "warning";
+export type ConversationMessageSpacing = "compact-bottom" | "compact-both" | "compact-top" | "default";
+export interface ConversationMessageViewProps extends Omit<HTMLAttributes<HTMLElement>, "children" | "role"> {
+    /** Optional product-owned activity or status content displayed before the body. */
+    activitySlot?: ReactNode;
+    /** Optional normalized previews or attachment controls. */
+    attachmentsSlot?: ReactNode;
+    /** Display-ready message body supplied by the application. */
+    body: ReactNode;
+    /** Product-owned actions or timestamp content after the message body. */
+    footerSlot?: ReactNode;
+    /** Optional display-ready heading or speaker content. */
+    headerSlot?: ReactNode;
+    /** Applies transcript grouping rhythm without making the application own CSS. */
+    isFirstInGroup?: boolean;
+    /** Applies transcript grouping rhythm without making the application own CSS. */
+    isLastInGroup?: boolean;
+    /** Selects the reusable transcript message anatomy. */
+    messageRole?: ConversationMessageRole;
+    /** Controlled meta content, such as a timestamp and message actions. */
+    metaSlot?: ReactNode;
+    /** Whether the controlled meta region is visually exposed. */
+    metaVisibility?: "hidden" | "visible";
+    ref?: Ref<HTMLElement>;
+    /** Controls outer transcript spacing. */
+    spacing?: ConversationMessageSpacing;
+    /** Applies a semantic color treatment to activity/system message bodies. */
+    tone?: ConversationMessageTone;
+}
+/**
+ * Controlled visual anatomy for a transcript message. Applications retain
+ * protocol decoding, markdown, actions, localization, and runtime state while
+ * the design system owns grouping, bubble, attachment, metadata, and footer
+ * presentation.
+ */
+export declare function ConversationMessageView({ activitySlot, attachmentsSlot, body, className, footerSlot, headerSlot, isFirstInGroup, isLastInGroup, metaSlot, metaVisibility, ref, messageRole, spacing, tone, ...rest }: ConversationMessageViewProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { type ConversationMessageRole, type ConversationMessageSpacing, type ConversationMessageTone, ConversationMessageView, type ConversationMessageViewProps, } from "./ConversationMessageView";

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

@@ -0,0 +1,47 @@
+import type { HTMLAttributes, Ref } from "react";
+export type DictationState = "idle" | "recording" | "processing" | "failed";
+export interface DictationLabels {
+    cancel: string;
+    insert: string;
+    insertAndSend: string;
+    retry: string;
+    start: string;
+}
+export interface DictationControlsProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Disables the idle start action. */
+    disabled?: boolean;
+    /** Elapsed recording duration in seconds. */
+    durationSeconds?: number;
+    /** Display-ready accessible labels for the action buttons. */
+    labels: DictationLabels;
+    /** Called when the current recording should be cancelled. */
+    onCancel?: () => void;
+    /** Called when a failed recording should be discarded. Falls back to onCancel. */
+    onDiscard?: () => void;
+    /** Called when the transcript should be inserted. */
+    onInsert?: () => void;
+    /** Called when the transcript should be inserted and sent. */
+    onInsertAndSend?: () => void;
+    /** Called when the failed recording should be retried. */
+    onRetry?: () => void;
+    /** Called when dictation should start. */
+    onStart?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    /** Normalized visual state. Audio lifecycle and persistence remain in the consumer. */
+    state?: DictationState;
+    /** Normalized microphone level, from 0 to 1. */
+    volume?: number;
+}
+export interface DictationOverlayProps extends Omit<DictationControlsProps, "children" | "disabled" | "onStart" | "ref"> {
+    /** Display-ready failure copy shown only when state is failed. */
+    failureMessage?: string;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled dictation controls. Consumers provide normalized state, text, and
+ * callbacks; audio capture, retries, translations, and persistence stay outside
+ * the design system.
+ */
+export declare function DictationControls({ className, disabled, durationSeconds, labels, onCancel, onDiscard, onInsert, onInsertAndSend, onRetry, onStart, ref, state, volume, ...rest }: DictationControlsProps): import("react").JSX.Element;
+/** A full-width controlled dictation surface for composer overlays. */
+export declare function DictationOverlay({ className, durationSeconds, failureMessage, labels, onCancel, onDiscard, onInsert, onInsertAndSend, onRetry, ref, state, volume, ...rest }: DictationOverlayProps): import("react").JSX.Element | null;

package/dist/components/ai/DictationControls/dictation-actions.d.ts

@@ -0,0 +1,23 @@
+type DictationActionState = "recording" | "processing" | "failed";
+interface DictationActionLabels {
+    cancel: string;
+    insert: string;
+    insertAndSend: string;
+    retry: string;
+}
+export declare function MicrophoneIcon(): import("react").JSX.Element;
+export declare function CloseIcon(): import("react").JSX.Element;
+export interface DictationActionsProps {
+    className?: string;
+    includeCancel?: boolean;
+    labels: DictationActionLabels;
+    onBrand?: boolean;
+    onCancel?: () => void;
+    onDiscard?: () => void;
+    onInsert?: () => void;
+    onInsertAndSend?: () => void;
+    onRetry?: () => void;
+    state: DictationActionState;
+}
+export declare function DictationActions({ className, includeCancel, labels, onCancel, onDiscard, onInsert, onInsertAndSend, onRetry, onBrand, state, }: DictationActionsProps): import("react").JSX.Element;
+export {};

package/dist/components/ai/DictationControls/dictation-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function formatDuration(seconds: number): string;
+export declare function dictationLevels(volume: number): number[];

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

@@ -0,0 +1 @@
+export { DictationControls, type DictationControlsProps, type DictationLabels, DictationOverlay, type DictationOverlayProps, type DictationState, } from "./DictationControls";

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

@@ -0,0 +1,30 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface EditedFilesSummaryFile {
+    additions: number;
+    deletions: number;
+    id?: string;
+    path: ReactNode;
+}
+export interface EditedFilesSummaryLabels {
+    description?: ReactNode;
+    review?: ReactNode;
+    showMore?: (count: number) => ReactNode;
+    title?: (count: number) => ReactNode;
+    undo?: ReactNode;
+}
+export interface EditedFilesSummaryProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    files: EditedFilesSummaryFile[];
+    labels?: EditedFilesSummaryLabels;
+    maxVisible?: number;
+    onReview?: () => void;
+    onUndo?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    totalAdditions: number;
+    totalDeletions: number;
+    totalFiles?: number;
+}
+/**
+ * Controlled edited-file summary. Consumers normalize diff data and own review
+ * or undo effects; DS owns the transcript summary visual and disclosure state.
+ */
+export declare function EditedFilesSummary({ className, files, labels, maxVisible, onReview, onUndo, ref, totalAdditions, totalDeletions, totalFiles, ...rest }: EditedFilesSummaryProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { EditedFilesSummary, type EditedFilesSummaryFile, type EditedFilesSummaryLabels, type EditedFilesSummaryProps, } from "./EditedFilesSummary";

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

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface FilterMenuOption {
+    label: string;
+    value: string;
+}
+export interface FilterMenuGroup {
+    id: string;
+    label: string;
+    options: FilterMenuOption[];
+    type: "radio" | "checkbox";
+}
+export interface FilterMenuProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    groups: FilterMenuGroup[];
+    onChange: (groupId: string, value: string | string[]) => void;
+    onClear?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    value: Record<string, string | string[]>;
+}
+export declare function FilterMenu({ groups, value, onChange, onClear, className, ref, ...rest }: FilterMenuProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { FilterMenu, type FilterMenuGroup, type FilterMenuOption, type FilterMenuProps, } from "./FilterMenu";

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

@@ -0,0 +1,12 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type HookActivityTone = "neutral" | "info" | "success" | "warning" | "danger";
+export interface HookActivityProps extends HTMLAttributes<HTMLDivElement> {
+    /** Optional supplementary detail rendered after the badge. */
+    detail?: ReactNode;
+    /** The hook event name displayed in the row. */
+    event: string;
+    ref?: Ref<HTMLDivElement>;
+    /** Badge tone reflecting the event kind. Defaults to "neutral". */
+    tone?: HookActivityTone;
+}
+export declare function HookActivity({ event, tone, detail, className, ref, ...rest }: HookActivityProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { HookActivity, type HookActivityProps, type HookActivityTone, } from "./HookActivity";

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

@@ -0,0 +1,30 @@
+import type { ReactNode } from "react";
+export interface IntegrationMarketplaceItem {
+    actionLabel?: ReactNode;
+    compact?: boolean;
+    description?: ReactNode;
+    icon?: ReactNode;
+    id: string;
+    installed?: boolean;
+    name: string;
+    summary?: ReactNode;
+}
+export interface IntegrationMarketplaceSection {
+    footer?: ReactNode;
+    id: string;
+    items: readonly IntegrationMarketplaceItem[];
+    title: ReactNode;
+}
+export interface IntegrationMarketplaceProps {
+    children?: ReactNode;
+    className?: string;
+    emptyLabel?: ReactNode;
+    error?: ReactNode;
+    filter?: ReactNode;
+    installed?: readonly IntegrationMarketplaceItem[];
+    loading?: boolean;
+    onAction?: (item: IntegrationMarketplaceItem) => void;
+    onOverflow?: (item: IntegrationMarketplaceItem) => void;
+    sections: readonly IntegrationMarketplaceSection[];
+}
+export declare function IntegrationMarketplace({ children, className, emptyLabel, error, filter, installed, loading, onAction, onOverflow, sections, }: IntegrationMarketplaceProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { IntegrationMarketplace, type IntegrationMarketplaceItem, type IntegrationMarketplaceProps, type IntegrationMarketplaceSection, } from "./IntegrationMarketplace";

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

@@ -0,0 +1,17 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface MessageActionsProps extends HTMLAttributes<HTMLDivElement> {
+    /** Feedback state — controls aria-pressed on thumb buttons. */
+    feedback?: "up" | "down";
+    /** Called when the user clicks the copy button. */
+    onCopy?: () => void;
+    /** Called when the user clicks the retry button. */
+    onRetry?: () => void;
+    /** Called when the user clicks the share button. */
+    onShare?: () => void;
+    /** Called when the user clicks the bad-response button. */
+    onThumbDown?: () => void;
+    /** Called when the user clicks the good-response button. */
+    onThumbUp?: () => void;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function MessageActions({ feedback, onCopy, onRetry, onThumbUp, onThumbDown, onShare, className, ref, ...rest }: MessageActionsProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { MessageActions, type MessageActionsProps, } from "./MessageActions";

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

@@ -0,0 +1,15 @@
+import type { Ref } from "react";
+export type MicState = "idle" | "recording" | "processing";
+export interface MicProps {
+    className?: string;
+    /** Disables the button. */
+    disabled?: boolean;
+    /** Accessible label. Default: "Voice input". */
+    label?: string;
+    /** Fired when the user clicks the mic button (toggle). */
+    onToggle?: () => void;
+    ref?: Ref<HTMLButtonElement>;
+    /** Current microphone state. Default: "idle". */
+    state?: MicState;
+}
+export declare function Mic({ state, onToggle, disabled, label, className, ref, }: MicProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { Mic, type MicProps, type MicState } from "./Mic";

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

@@ -0,0 +1,38 @@
+import type { HTMLAttributes, ReactNode } from "react";
+/** A normalized model choice and its selected effort level. */
+export interface ModelEffortOption {
+    /** Secondary explanatory copy shown below the model and effort. */
+    description: ReactNode;
+    /** The selected effort level shown in the trigger. */
+    effort: ReactNode;
+    /** Primary model label. */
+    label: ReactNode;
+    /** Stable controlled value returned by `onChange`. */
+    value: string;
+}
+export interface ModelEffortSelectorProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "title"> {
+    /** Disables the trigger while retaining the selected visual state. */
+    disabled?: boolean;
+    /** Fallback label used when `value` does not match an option. */
+    fallbackLabel?: ReactNode;
+    /** Label for the optional management intent. */
+    manageModelsLabel?: ReactNode;
+    /** Reports the newly selected normalized option value. */
+    onChange: (value: string) => void;
+    /** Reports the optional model-management intent. */
+    onManageModels?: () => void;
+    /** App-normalized model and effort choices. */
+    options: readonly ModelEffortOption[];
+    /** Accessible menu title. */
+    title?: ReactNode;
+    /** Controlled selected option value. */
+    value: string;
+}
+/**
+ * Controlled model-and-effort picker presentation.
+ *
+ * Provider catalogs, availability, routing, persistence, and model-management
+ * workflows remain application responsibilities. This component renders only
+ * normalized choices and emits selection or management intents.
+ */
+export declare function ModelEffortSelector({ className, disabled, fallbackLabel, manageModelsLabel, onChange, onManageModels, options, title, value, ...rest }: ModelEffortSelectorProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { type ModelEffortOption, ModelEffortSelector, type ModelEffortSelectorProps, } from "./ModelEffortSelector";

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

@@ -0,0 +1,15 @@
+import type { HTMLAttributes, Ref } from "react";
+export type PlanStepStatus = "pending" | "running" | "done" | "failed";
+export interface PlanStep {
+    id: string;
+    label: string;
+    status?: PlanStepStatus;
+}
+export interface PlanStepsProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    ref?: Ref<HTMLDivElement>;
+    /** Ordered list of task steps. */
+    steps: PlanStep[];
+    /** Optional section title. */
+    title?: string;
+}
+export declare function PlanSteps({ title, steps, className, ref, ...rest }: PlanStepsProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { type PlanStep, type PlanStepStatus, PlanSteps, type PlanStepsProps, } from "./PlanSteps";

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

@@ -0,0 +1,41 @@
+import { type ReactNode, type Ref } from "react";
+export interface PromptInputAttachment {
+    id: string;
+    label: string;
+}
+export interface PromptInputModel {
+    description?: string;
+    icon?: ReactNode;
+    label: string;
+    value: string;
+}
+export declare const DEFAULT_EFFORT_MODELS: PromptInputModel[];
+export interface PromptInputProps {
+    /** Menu content opened by the leading attach button (e.g. `MenuItem`s for
+     * "Files and folders", "Goal", "Plan mode", plugin entries). When omitted,
+     * the attach button renders as a plain, inert `IconButton` (unchanged
+     * default behavior) — it has no `onClick` of its own to attach handlers to. */
+    attachMenu?: ReactNode;
+    attachments?: PromptInputAttachment[];
+    className?: string;
+    disabled?: boolean;
+    error?: ReactNode;
+    maxLength?: number;
+    mode?: "business" | "advanced";
+    model?: string;
+    models?: PromptInputModel[];
+    onModelChange?: (value: string) => void;
+    onRemoveAttachment?: (id: string) => void;
+    onStop?: () => void;
+    onSubmit?: (v: string) => void;
+    onValueChange?: (v: string) => void;
+    placeholder?: string;
+    ref?: Ref<HTMLFormElement>;
+    showMic?: boolean;
+    streaming?: boolean;
+    /** Controlled text */
+    value?: string;
+    /** default = card composer; rounded = pill follow-up bar */
+    variant?: "default" | "rounded";
+}
+export declare function PromptInput({ value, onValueChange, placeholder, disabled, onSubmit, streaming, onStop, error, attachments, attachMenu, onRemoveAttachment, maxLength, models, model, onModelChange, showMic, mode, variant, className, ref, }: PromptInputProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { DEFAULT_EFFORT_MODELS, PromptInput, type PromptInputAttachment, type PromptInputModel, type PromptInputProps, } from "./PromptInput";

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

@@ -0,0 +1,102 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface ProviderDiagnosticsModel {
+    /** Optional app-normalized description. */
+    description?: string;
+    /** Stable model identifier returned with model-management intents. */
+    id: string;
+    /** Human-readable model name. */
+    label: string;
+}
+export interface ProviderDiagnosticsLabels {
+    add: string;
+    addCustomModelTitle: string;
+    adding: string;
+    addModel: string;
+    cancel: string;
+    copy: string;
+    copyDiagnostic: string;
+    custom: string;
+    diagnostics: string;
+    diagnosticsEmpty: string;
+    diagnosticsLoading: string;
+    diagnosticsTitle: string;
+    discovered: string;
+    loading: string;
+    modelId: string;
+    modelIdPlaceholder: string;
+    noModels: string;
+    noSearchMatches: string;
+    refresh: string;
+    refreshDiagnostic: string;
+    refreshing: string;
+    removeModel: (modelId: string) => string;
+    retry: string;
+    retrying: string;
+    searchPlaceholder: string;
+    updated: (time: string) => string;
+}
+export interface ProviderDiagnosticsAddModel {
+    canSubmit: boolean;
+    error?: string | null;
+    onClose: () => void;
+    onSubmit: () => void;
+    onValueChange: (value: string) => void;
+    open: boolean;
+    saving?: boolean;
+    value: string;
+}
+export interface ProviderDiagnosticsOutput {
+    content?: string | null;
+    loading?: boolean;
+    onClose: () => void;
+    onCopy?: () => void;
+    onRefresh: () => void;
+    open: boolean;
+}
+export interface ProviderDiagnosticsSheetProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange" | "title"> {
+    /** Controlled custom-model form state and callbacks. */
+    addModel: ProviderDiagnosticsAddModel;
+    /** Additional models defined by the app's provider configuration. */
+    customModels?: readonly ProviderDiagnosticsModel[];
+    /** Discovered models normalized by the consuming app. */
+    discoveredModels?: readonly ProviderDiagnosticsModel[];
+    /** Optional snapshot timestamp label, already formatted by the app. */
+    fetchedAtLabel?: string | null;
+    /** Localized text and accessible labels. */
+    labels: ProviderDiagnosticsLabels;
+    /** Current catalog loading state. */
+    loading?: boolean;
+    /** Requests dismissal of the catalog. */
+    onClose: () => void;
+    /** Controlled catalog search value. */
+    onQueryChange: (query: string) => void;
+    /** Reports the app-owned request to refresh discovered models. */
+    onRefreshModels: () => void;
+    /** Reports the app-owned intent to delete a custom model. */
+    onRemoveCustomModel: (modelId: string) => void;
+    /** Opens the controlled add-custom-model form. */
+    onRequestAddModel: () => void;
+    /** Opens the controlled diagnostic-output sheet. */
+    onRequestDiagnostics: () => void;
+    /** Whether the catalog is visible. */
+    open: boolean;
+    /** Controlled diagnostic-output state and callbacks. */
+    output: ProviderDiagnosticsOutput;
+    /** App-normalized catalog error. */
+    providerError?: string | null;
+    /** Controlled catalog query. */
+    query: string;
+    /** Marks an individual custom-model deletion as pending. */
+    removingModelId?: string | null;
+    /** Optional stable identifier for all sheet controls. */
+    testId?: string;
+    /** Provider display name. */
+    title: ReactNode;
+}
+/**
+ * Controlled provider-model catalog and diagnostic-output presentation.
+ *
+ * Provider discovery, diagnostics, persistence, clipboard use, translations,
+ * and error derivation deliberately remain in the consuming application.
+ */
+export declare function ProviderDiagnosticsSheet({ addModel, className, customModels, discoveredModels, fetchedAtLabel, labels, loading, onClose, onQueryChange, onRefreshModels, onRemoveCustomModel, onRequestAddModel, onRequestDiagnostics, open, output, providerError, query, removingModelId, testId, title, ...rest }: ProviderDiagnosticsSheetProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { type ProviderDiagnosticsAddModel, type ProviderDiagnosticsLabels, type ProviderDiagnosticsModel, type ProviderDiagnosticsOutput, ProviderDiagnosticsSheet, type ProviderDiagnosticsSheetProps, } from "./ProviderDiagnosticsSheet";

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

@@ -0,0 +1,88 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface ProviderModelSelectorModelRow {
+    description?: string;
+    favoriteKey: string;
+    modelId: string;
+    modelLabel: string;
+    provider: string;
+    providerLabel: string;
+}
+export type ProviderModelSelectorModelSelection = {
+    kind: "models";
+    rows: readonly ProviderModelSelectorModelRow[];
+} | {
+    kind: "loading";
+} | {
+    kind: "error";
+    message: string;
+};
+export interface ProviderModelSelectorProvider {
+    id: string;
+    label: string;
+    modelSelection: ProviderModelSelectorModelSelection;
+}
+export type ProviderModelSelectorViewState = {
+    kind: "all";
+} | {
+    kind: "provider";
+    providerId: string;
+    providerLabel: string;
+};
+export interface ProviderModelSelectorLabels {
+    error: ReactNode;
+    favoriteModel: string;
+    favorites: ReactNode;
+    loadingShort: ReactNode;
+    modelCount: (count: number) => ReactNode;
+    modelCountPlural: (count: number) => ReactNode;
+    noMatches: ReactNode;
+    retry: ReactNode;
+    retrying: ReactNode;
+    unfavoriteModel: string;
+}
+export interface ProviderModelSelectorModelRowProps {
+    isFavorite: boolean;
+    isSelected: boolean;
+    labels: Pick<ProviderModelSelectorLabels, "favoriteModel" | "unfavoriteModel">;
+    onSelect: (provider: string, modelId: string) => void;
+    onToggleFavorite?: (provider: string, modelId: string) => void;
+    renderProviderIcon?: (providerId: string) => ReactNode;
+    row: ProviderModelSelectorModelRow;
+}
+export interface ProviderModelSelectorModelListRenderArgs {
+    labels: Pick<ProviderModelSelectorLabels, "favoriteModel" | "unfavoriteModel">;
+    /** DS-owned class for a native virtualized list host. */
+    modelListClassName: string;
+    /** DS-owned class for a native virtualized list content container. */
+    modelListContentClassName: string;
+    onSelect: (provider: string, modelId: string) => void;
+    onToggleFavorite?: (provider: string, modelId: string) => void;
+    renderProviderIcon?: (providerId: string) => ReactNode;
+    rows: readonly ProviderModelSelectorModelRow[];
+}
+export interface ProviderModelSelectorViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> {
+    favoriteKeys?: ReadonlySet<string>;
+    isRetryingProvider?: boolean;
+    labels: ProviderModelSelectorLabels;
+    /** Shows the DS loading presentation while an application-owned host initializes. */
+    loading?: boolean;
+    onDrillDown: (providerId: string, providerLabel: string) => void;
+    onRetryProvider?: (providerId: string) => void;
+    onSelect: (provider: string, modelId: string) => void;
+    onToggleFavorite?: (provider: string, modelId: string) => void;
+    providers: readonly ProviderModelSelectorProvider[];
+    renderModelList?: (args: ProviderModelSelectorModelListRenderArgs) => ReactNode;
+    renderProviderIcon?: (providerId: string) => ReactNode;
+    searchQuery: string;
+    selectedModel: string;
+    selectedProvider: string;
+    state: ProviderModelSelectorViewState;
+    visibleModelRows?: readonly ProviderModelSelectorModelRow[];
+}
+export declare function ProviderModelSelectorModelRow({ isFavorite, isSelected, labels, onSelect, onToggleFavorite, renderProviderIcon, row, }: ProviderModelSelectorModelRowProps): import("react").JSX.Element;
+/**
+ * Controlled provider/model selector content. Applications normalize provider
+ * and model data, own popup/sheet lifecycle, localization, platform policy,
+ * and side effects; this component owns the reusable selector presentation.
+ */
+export declare function ProviderModelSelectorView({ className, favoriteKeys, isRetryingProvider, labels, loading, onDrillDown, onRetryProvider, onSelect, onToggleFavorite, providers, renderModelList, renderProviderIcon, searchQuery, selectedModel, selectedProvider, state, visibleModelRows, ...rest }: ProviderModelSelectorViewProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export * from "./ProviderModelSelectorView";

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

@@ -0,0 +1,7 @@
+import type { MouseEvent, PointerEvent } from "react";
+import type { ProviderModelSelectorModelRow } from "./ProviderModelSelectorView";
+export declare function handleModelFavoriteClick(onToggleFavorite: (provider: string, modelId: string) => void, row: ProviderModelSelectorModelRow, event: MouseEvent<HTMLButtonElement>): void;
+export declare function handleModelFavoritePointerDown(event: PointerEvent<HTMLButtonElement>): void;
+export declare function handleModelRowSelect(onSelect: (provider: string, modelId: string) => void, provider: string, modelId: string): void;
+export declare function handleProviderDrillDown(onDrillDown: (providerId: string, providerLabel: string) => void, providerId: string, providerLabel: string): void;
+export declare function handleProviderRetry(onRetryProvider: (providerId: string) => void, providerId: string): void;