@amsterdamdatalabs/enact-design-system 0.1.12 → 0.1.24

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";

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

@@ -0,0 +1,34 @@
+export interface VoiceControlsProps {
+    /** Disables controls and shows a busy state on the stop action. */
+    busy?: boolean;
+    /** Additional class name applied to the panel. */
+    className?: string;
+    /** Accessible label for the control group. Default: "Voice controls". */
+    label?: string;
+    /** Indicates that microphone input is currently muted. */
+    muted?: boolean;
+    /** Accessible label for the mute action. Default: "Mute microphone". */
+    muteLabel?: string;
+    /** Called when the voice session should stop. */
+    onStop?: () => void;
+    /** Called when the mute state should be toggled. */
+    onToggleMute?: () => void;
+    /** Indicates that incoming voice output is active. */
+    speaking?: boolean;
+    /** Accessible label for the stop action. Default: "Stop voice". */
+    stopLabel?: string;
+    /** Accessible label for the unmute action. Default: "Unmute microphone". */
+    unmuteLabel?: string;
+    /** Normalized microphone volume level, from 0 to 1. */
+    volume?: number;
+    /** Optional accessible description for the audio-level visualization. */
+    volumeLabel?: string;
+}
+/**
+ * Controlled visual surface for an active voice session.
+ *
+ * The owning application supplies normalized volume/state and intent callbacks;
+ * audio capture, voice lifecycle, translations, and persistence remain outside
+ * the design system.
+ */
+export declare function VoiceControls({ busy, className, label, muteLabel, muted, onStop, onToggleMute, speaking, stopLabel, unmuteLabel, volume, volumeLabel, }: VoiceControlsProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { VoiceControls, type VoiceControlsProps } from "./VoiceControls";

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

@@ -0,0 +1,37 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface WorkspaceComposerQueueItem {
+    editLabel: string;
+    id: string;
+    onEdit: () => void;
+    onSend: () => void;
+    sendLabel: string;
+    text: string;
+}
+export interface WorkspaceComposerViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Controlled attachment pills or other composer-adjacent content. */
+    attachmentSlot?: ReactNode;
+    /** Caller-owned autocomplete overlay anchored to the input region. */
+    autocompleteSlot?: ReactNode;
+    /** Caller-owned error content announced above the composer surface. */
+    errorSlot?: ReactNode;
+    /** Caller-owned footer content below the composer surface. */
+    footerSlot?: ReactNode;
+    /** The normalized input and toolbar visual supplied by the application. */
+    inputSlot: ReactNode;
+    /** Caller-owned lightbox or modal content associated with attachments. */
+    lightboxSlot?: ReactNode;
+    /** Prevents interaction with the composed surface while an app-owned action runs. */
+    locked?: boolean;
+    /** Caller-owned picker overlay, such as a GitHub issue search. */
+    pickerSlot?: ReactNode;
+    /** Controlled queued-message rows and their app-owned edit/send intents. */
+    queueItems?: readonly WorkspaceComposerQueueItem[];
+    ref?: Ref<HTMLDivElement>;
+    testId?: string;
+}
+/**
+ * Controlled web composer frame. The design system owns the frame, queue,
+ * attachment, input-region, error, and footer presentation; applications own
+ * editing, uploads, autocomplete, session state, and every mutation.
+ */
+export declare function WorkspaceComposerView({ attachmentSlot, autocompleteSlot, className, errorSlot, footerSlot, inputSlot, lightboxSlot, locked, pickerSlot, queueItems, ref, testId, ...rest }: WorkspaceComposerViewProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { type WorkspaceComposerQueueItem, WorkspaceComposerView, type WorkspaceComposerViewProps, } from "./WorkspaceComposerView";

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

@@ -0,0 +1,22 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface WorkspaceDraftComposerViewProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    /** The controlled composer input surface. */
+    composer: ReactNode;
+    /** Display-ready configuration content shown before submission. */
+    configuration?: ReactNode;
+    /** Display-ready validation or submission error. */
+    error?: ReactNode;
+    /** Optional controlled import action placed above the composer. */
+    importAction?: ReactNode;
+    ref?: Ref<HTMLElement>;
+    /** Application-owned agent stream content. */
+    stream?: ReactNode;
+    /** Selects stream content over the configuration surface. */
+    submitting?: boolean;
+}
+/**
+ * Controlled workspace draft-composer frame. The app retains agent creation,
+ * attachments, draft persistence, input focus, imports, and runtime effects;
+ * DS owns the web canvas, configuration, error, import, and composer layout.
+ */
+export declare function WorkspaceDraftComposerView({ className, composer, configuration, error, importAction, ref, stream, submitting, ...rest }: WorkspaceDraftComposerViewProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { WorkspaceDraftComposerView, type WorkspaceDraftComposerViewProps, } from "./WorkspaceDraftComposerView";

package/dist/components/content/ArtifactCard/ArtifactCard.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface ArtifactCardProps extends HTMLAttributes<HTMLDivElement> {
+    /** The artifact body rendered in the card. */
+    children: ReactNode;
+    /** When provided, renders an export Button. */
+    onExport?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    /** The artifact title displayed in the card header. */
+    title: string;
+}
+export declare function ArtifactCard({ title, children, onExport, className, ref, ...rest }: ArtifactCardProps): import("react").JSX.Element;

package/dist/components/content/ArtifactCard/index.d.ts

@@ -0,0 +1 @@
+export { ArtifactCard, type ArtifactCardProps } from "./ArtifactCard";

package/dist/components/content/ArtifactPreviewFrame/ArtifactPreviewFrame.d.ts

@@ -0,0 +1,25 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ArtifactPreviewFrameKind = "audio" | "code" | "document" | "image" | "video";
+export type ArtifactPreviewFrameState = "empty" | "error" | "loading" | "ready";
+export interface ArtifactPreviewFrameProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Ready content supplied by the consumer's browser/media lifecycle. */
+    children?: ReactNode;
+    /** Display-ready empty state supplied by the consumer. */
+    empty?: ReactNode;
+    /** Display-ready error state supplied by the consumer. */
+    error?: ReactNode;
+    /** Selects the DS-owned media and code surface treatment. */
+    kind?: ArtifactPreviewFrameKind;
+    /** Display-ready loading state supplied by the consumer. */
+    loading?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    /** The application-owned preview lifecycle state. */
+    state?: ArtifactPreviewFrameState;
+}
+/**
+ * A controlled asset preview surface. The consumer owns artifact typing, URL
+ * policy, fetching, sandboxing, and browser/media lifecycles; this component
+ * owns the theme-native preview frame and its ready, loading, error, and empty
+ * visual states.
+ */
+export declare function ArtifactPreviewFrame({ children, className, empty, error, kind, loading, ref, state, ...rest }: ArtifactPreviewFrameProps): import("react").JSX.Element;

package/dist/components/content/ArtifactPreviewFrame/index.d.ts

@@ -0,0 +1 @@
+export { ArtifactPreviewFrame, type ArtifactPreviewFrameKind, type ArtifactPreviewFrameProps, type ArtifactPreviewFrameState, } from "./ArtifactPreviewFrame";

package/dist/components/content/CodeBlock/CodeBlock.d.ts

@@ -0,0 +1,22 @@
+import type { HTMLAttributes, Ref } from "react";
+import { type SyntaxCodeLine } from "../SyntaxCodeLines";
+export interface CodeBlockProps extends HTMLAttributes<HTMLDivElement> {
+    code: string;
+    /** Localized confirmation label. Defaults to the existing English label. */
+    copiedLabel?: string;
+    copyable?: boolean;
+    /** Duration in milliseconds for the copied confirmation. Defaults to 2000. */
+    copyFeedbackDuration?: number;
+    /** Localized copy-control label. Defaults to the existing English label. */
+    copyLabel?: string;
+    fileName?: string;
+    /** Display-ready syntax lines. Parsing and tokenization remain external. */
+    highlightedLines?: readonly SyntaxCodeLine[];
+    language?: string;
+    ref?: Ref<HTMLElement>;
+    showLineNumbers?: boolean;
+    /** One-based line number used when rendering highlighted lines with a gutter. */
+    startLineNumber?: number;
+    wrap?: boolean;
+}
+export declare function CodeBlock({ code, language, showLineNumbers, copyable, copyLabel, copiedLabel, copyFeedbackDuration, wrap, fileName, highlightedLines, startLineNumber, className, ref, ...rest }: CodeBlockProps): import("react").JSX.Element;

package/dist/components/content/CodeBlock/index.d.ts

@@ -0,0 +1,2 @@
+export type { CodeBlockProps } from "./CodeBlock";
+export { CodeBlock } from "./CodeBlock";

package/dist/components/content/ComponentPreview/ComponentPreview.d.ts

@@ -0,0 +1,13 @@
+import type { ReactNode } from "react";
+import type { Align } from "../../layout/shared/scale";
+export interface ComponentPreviewProps {
+    code: string;
+    description?: string;
+    /** Optional anchor id for in-page navigation. */
+    id?: string;
+    preview: ReactNode;
+    /** Cross-axis alignment of preview content. Default: center. */
+    previewAlign?: Align;
+    title: string;
+}
+export declare function ComponentPreview({ id, title, description, preview, code, previewAlign, }: ComponentPreviewProps): import("react").JSX.Element;

package/dist/components/content/ComponentPreview/index.d.ts

@@ -0,0 +1,2 @@
+export type { ComponentPreviewProps } from "./ComponentPreview";
+export { ComponentPreview } from "./ComponentPreview";

package/dist/components/content/DiffStat/DiffStat.d.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface DiffStatProps extends HTMLAttributes<HTMLSpanElement> {
+    additions: number;
+    compact?: boolean;
+    deletions: number;
+    ref?: Ref<HTMLSpanElement>;
+    showZero?: boolean;
+}
+export declare function DiffStat({ additions, compact, deletions, showZero, className, ref, ...rest }: DiffStatProps): import("react").JSX.Element;

package/dist/components/content/DiffStat/index.d.ts

@@ -0,0 +1 @@
+export { DiffStat, type DiffStatProps } from "./DiffStat";

package/dist/components/content/DiffView/DiffView.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, Ref } from "react";
+import type { DiffHunk } from "./diff";
+export interface DiffViewProps extends HTMLAttributes<HTMLElement> {
+    /** Optional file name shown in the header. */
+    fileName?: string;
+    /** Pre-computed hunks. Provide either `hunks` or `oldText`+`newText`. */
+    hunks?: DiffHunk[];
+    /** Display layout. Defaults to "unified". */
+    mode?: "unified" | "split";
+    /** Target text. Used with `oldText` to auto-compute hunks via LCS. */
+    newText?: string;
+    /** Source text. Used with `newText` to auto-compute hunks via LCS. */
+    oldText?: string;
+    ref?: Ref<HTMLElement>;
+}
+export declare function DiffView({ hunks: hunksProp, oldText, newText, mode, fileName, className, ref, ...rest }: DiffViewProps): import("react").JSX.Element;

package/dist/components/content/DiffView/diff.d.ts

@@ -0,0 +1,20 @@
+export interface DiffLine {
+    content: string;
+    newNo?: number;
+    oldNo?: number;
+    type: "add" | "del" | "context";
+}
+export interface DiffHunk {
+    header?: string;
+    lines: DiffLine[];
+}
+/**
+ * Compute the Longest Common Subsequence of two string arrays.
+ * Returns the common elements in order.
+ */
+export declare function lcs(a: string[], b: string[]): string[];
+/**
+ * Compute diff hunks from plain old/new text strings.
+ * Uses a simple line-level LCS to produce add/del/context DiffLines.
+ */
+export declare function computeHunks(oldText: string, newText: string): DiffHunk[];

package/dist/components/content/DiffView/index.d.ts

@@ -0,0 +1,2 @@
+export { DiffView, type DiffViewProps } from "./DiffView";
+export type { DiffHunk, DiffLine } from "./diff";

package/dist/components/content/DocumentPreviewFrame/DocumentPreviewFrame.d.ts

@@ -0,0 +1,15 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type DocumentPreviewFrameState = "empty" | "error" | "loading" | "ready";
+export interface DocumentPreviewFrameProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    children?: ReactNode;
+    hint?: ReactNode;
+    message?: ReactNode;
+    onRetry?: () => void;
+    ref?: Ref<HTMLDivElement>;
+    retryLabel?: string;
+    sandbox?: string;
+    srcDoc?: string;
+    state?: DocumentPreviewFrameState;
+    title?: string;
+}
+export declare function DocumentPreviewFrame({ children, className, hint, message, onRetry, ref, retryLabel, sandbox, srcDoc, state, title, ...rest }: DocumentPreviewFrameProps): import("react").JSX.Element;

package/dist/components/content/DocumentPreviewFrame/index.d.ts

@@ -0,0 +1 @@
+export { DocumentPreviewFrame, type DocumentPreviewFrameProps, type DocumentPreviewFrameState, } from "./DocumentPreviewFrame";

package/dist/components/content/DocumentViewer/DocumentViewer.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import type { ActivityTimelineItem } from "../../ai/ActivityTimeline/ActivityTimeline";
+import type { SourceCardProps } from "../SourceCard/SourceCard";
+export interface DocumentChapter {
+    id: string;
+    label: string;
+}
+export interface DocumentViewerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    activeChapterId?: string;
+    activity?: ActivityTimelineItem[];
+    body: ReactNode;
+    chapters?: DocumentChapter[];
+    onChapterSelect?: (id: string) => void;
+    ref?: Ref<HTMLDivElement>;
+    sources?: SourceCardProps[];
+    title: string;
+}
+export declare function DocumentViewer({ title, body, chapters, activeChapterId: controlledActiveChapterId, onChapterSelect, activity, sources, className, ref, ...rest }: DocumentViewerProps): import("react").JSX.Element;

package/dist/components/content/DocumentViewer/index.d.ts

@@ -0,0 +1 @@
+export { type DocumentChapter, DocumentViewer, type DocumentViewerProps, } from "./DocumentViewer";

package/dist/components/content/FilePreviewSurface/FilePreviewSurface.d.ts

@@ -0,0 +1,44 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type SyntaxCodeLine } from "../SyntaxCodeLines";
+export interface FilePreviewSelectedRange {
+    /** Inclusive one-based source line where the application selection ends. */
+    end: number;
+    /** Inclusive one-based source line where the application selection starts. */
+    start: number;
+}
+interface FilePreviewSurfaceBaseProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    ref?: Ref<HTMLDivElement>;
+}
+export interface FilePreviewCodeSurfaceProps extends FilePreviewSurfaceBaseProps {
+    /** Reduces source padding for dense file-preview contexts. */
+    compact?: boolean;
+    /** Selects the pre-tokenized source presentation. */
+    kind: "code";
+    /** Pre-tokenized source lines; tokenization and source selection stay external. */
+    lines: readonly SyntaxCodeLine[];
+    /** Optional inclusive, one-based highlighted source range. */
+    selectedRange?: FilePreviewSelectedRange;
+}
+export interface FilePreviewMarkdownSurfaceProps extends FilePreviewSurfaceBaseProps {
+    /** Adapter-rendered markdown. Parsing, links, and custom render rules stay external. */
+    children: ReactNode;
+    /** Selects the rendered markdown presentation. */
+    kind: "markdown";
+}
+export interface FilePreviewImageSurfaceProps extends FilePreviewSurfaceBaseProps {
+    /** Accessible image description; omit only for decorative previews. */
+    alt?: string;
+    /** Selects the policy-approved image preview presentation. */
+    kind: "image";
+    /** A consumer-owned, policy-approved image source URL. */
+    src: string;
+}
+/**
+ * A controlled, frameless preview body for file content inside `FileFrame`.
+ * Consumers retain file access, source parsing, URL policy, scrolling policy,
+ * and selection/scroll synchronization. This component owns only the
+ * theme-native code, markdown, and image presentations.
+ */
+export type FilePreviewSurfaceProps = FilePreviewCodeSurfaceProps | FilePreviewMarkdownSurfaceProps | FilePreviewImageSurfaceProps;
+export declare function FilePreviewSurface(props: FilePreviewSurfaceProps): import("react").JSX.Element;
+export {};

package/dist/components/content/FilePreviewSurface/index.d.ts

@@ -0,0 +1,2 @@
+export type { FilePreviewCodeSurfaceProps, FilePreviewImageSurfaceProps, FilePreviewMarkdownSurfaceProps, FilePreviewSelectedRange, FilePreviewSurfaceProps, } from "./FilePreviewSurface";
+export { FilePreviewSurface } from "./FilePreviewSurface";

package/dist/components/content/HighlightedCodeBlock/HighlightedCodeBlock.d.ts

@@ -0,0 +1,22 @@
+import type { HTMLAttributes } from "react";
+import { type SyntaxCodeLine } from "../SyntaxCodeLines";
+export type HighlightedCodeCopyState = "idle" | "copied";
+export interface HighlightedCodeBlockProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The unparsed source, used when display-ready lines are unavailable. */
+    code: string;
+    /** Localized label announced and shown after the app reports a successful copy. */
+    copiedLabel?: string;
+    /** Hide the copy control while retaining the rest of the presentation. */
+    copyable?: boolean;
+    /** Localized label announced by the copy control in its idle state. */
+    copyLabel?: string;
+    /** Controlled copy feedback state; the DS does not access the clipboard. */
+    copyState?: HighlightedCodeCopyState;
+    /** Display-ready syntax lines. Parsing and caching remain external. */
+    highlightedLines?: readonly SyntaxCodeLine[];
+    /** Optional normalized language label for the presentation toolbar. */
+    language?: string;
+    /** App-owned clipboard action. The DS only invokes this callback. */
+    onCopyCode: () => void;
+}
+export declare function HighlightedCodeBlock({ code, highlightedLines, language, copyLabel, copiedLabel, copyState, onCopyCode, copyable, className, ...rest }: HighlightedCodeBlockProps): import("react").JSX.Element;

package/dist/components/content/HighlightedCodeBlock/index.d.ts

@@ -0,0 +1 @@
+export { HighlightedCodeBlock, type HighlightedCodeBlockProps, type HighlightedCodeCopyState, } from "./HighlightedCodeBlock";

package/dist/components/content/MarkdownRendererView/MarkdownRendererView.d.ts

@@ -0,0 +1,49 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface MarkdownRendererViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Rendered markdown content supplied by the application adapter. */
+    children?: ReactNode;
+    /** Selects the compact presentation used by dense content surfaces. */
+    compact?: boolean;
+    ref?: Ref<HTMLDivElement>;
+}
+export interface MarkdownRendererDetailsViewProps {
+    children?: ReactNode;
+    expanded: boolean;
+    onExpandedChange: (expanded: boolean) => void;
+    summary: ReactNode;
+}
+export interface MarkdownRendererImageViewProps {
+    alt?: string;
+    fallbackText?: ReactNode;
+    flow?: boolean;
+    height: number;
+    onActivate?: () => void;
+    /** Called when the policy-approved image cannot be decoded or loaded. */
+    onError?: () => void;
+    src: string;
+    width: number;
+}
+export interface MarkdownRendererImageTextRowProps {
+    children?: ReactNode;
+    images: ReactNode;
+}
+export interface MarkdownRendererListItemViewProps {
+    children?: ReactNode;
+    marker: ReactNode;
+}
+/**
+ * Controlled presentation shell for application-owned markdown renderers.
+ *
+ * The application remains responsible for parsing, custom render rules,
+ * links, images, and platform rendering. This component owns only the
+ * reusable DOM boundary and presentation state around those supplied nodes.
+ */
+export declare function MarkdownRendererView({ children, className, compact, ref, ...rest }: MarkdownRendererViewProps): import("react").JSX.Element;
+/** Controlled disclosure shell for application-parsed `<details>` blocks. */
+export declare function MarkdownRendererDetailsView({ children, expanded, onExpandedChange, summary, }: MarkdownRendererDetailsViewProps): import("react").JSX.Element;
+/** Controlled image shell. The application supplies a policy-approved URL and action. */
+export declare function MarkdownRendererImageView({ alt, fallbackText, flow, height, onActivate, onError, src, width, }: MarkdownRendererImageViewProps): import("react").JSX.Element;
+/** Layout shell for policy-approved flow images paired with markdown content. */
+export declare function MarkdownRendererImageTextRow({ children, images, }: MarkdownRendererImageTextRowProps): import("react").JSX.Element;
+/** Structural row used by application-defined ordered and bullet-list rules. */
+export declare function MarkdownRendererListItemView({ children, marker, }: MarkdownRendererListItemViewProps): import("react").JSX.Element;

package/dist/components/content/MarkdownRendererView/index.d.ts

@@ -0,0 +1 @@
+export { MarkdownRendererDetailsView, type MarkdownRendererDetailsViewProps, MarkdownRendererImageTextRow, type MarkdownRendererImageTextRowProps, MarkdownRendererImageView, type MarkdownRendererImageViewProps, MarkdownRendererListItemView, type MarkdownRendererListItemViewProps, MarkdownRendererView, type MarkdownRendererViewProps, } from "./MarkdownRendererView";

package/dist/components/content/MarkdownView/MarkdownView.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MarkdownView — renders a markdown string to React elements using DS
+ * primitives (Heading, Text, CodeBlock). Zero external parser or sanitizer
+ * dependencies. All output is React elements; raw HTML / angle-bracket content
+ * in the source string is passed through as text and escaped by React.
+ *
+ * Supported subset:
+ *   - ATX headings `#`..`######`
+ *   - Paragraphs
+ *   - Bold `**` / `__`
+ *   - Italic `*` / `_`
+ *   - Inline code `` ` ``
+ *   - Links `[text](url)` — external http(s) links open in a new tab
+ *     with `rel="noopener noreferrer"`; relative / non-http links stay in tab
+ *   - Unordered lists `- ` / `* `
+ *   - Ordered lists `1. `
+ *   - Blockquote `>`
+ *   - Horizontal rule `---`
+ *   - Fenced code blocks ` ``` ` — delegates to `CodeBlock` (language captured)
+ */
+import type { HTMLAttributes, Ref } from "react";
+export interface MarkdownViewProps extends HTMLAttributes<HTMLDivElement> {
+    /** Raw markdown string to render. */
+    content: string;
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function MarkdownView({ content, className, ref, ...rest }: MarkdownViewProps): import("react").JSX.Element;

package/dist/components/content/MarkdownView/index.d.ts

@@ -0,0 +1,2 @@
+export type { MarkdownViewProps } from "./MarkdownView";
+export { MarkdownView } from "./MarkdownView";