@mithrl/design-system 0.4.0 → 0.4.2

package/dist/components/approval-card/ApprovalCard.d.ts

@@ -1,70 +1,73 @@
-import { type HTMLAttributes, type ReactNode } from "react";
+import { type FormHTMLAttributes } from "react";
+import { type DropdownMenuContentProps } from "../dropdown-menu/DropdownMenu";
 
-/** One selectable answer on an approval question. */
-export interface ApprovalOption {
+export type ApprovalCardMode = "single" | "multi";
+export type ApprovalCardOption = {
     id: string;
-    label: string;
-    /** Short clarifier shown under the label. Keep it to one plain sentence. */
-    description?: string;
-}
-/** A single question the agent asks before it acts. */
-export interface ApprovalQuestion {
+    title: string;
+    subtitle?: string;
+    disabled?: boolean;
+};
+export type ApprovalCardQuestion = {
     id: string;
-    /** The question itself, phrased the way a colleague would ask it. */
-    prompt: string;
-    /** Optional context sentence shown under the prompt. */
-    helpText?: ReactNode;
-    options: ApprovalOption[];
-    /** Allow more than one option. Defaults to single choice. */
-    multiSelect?: boolean;
-}
-/** Selected option ids keyed by question id. */
-export type ApprovalAnswers = Record<string, string[]>;
-type RestrictedApprovalCardAttribute = "children" | "onSubmit" | "role";
-export type ApprovalCardProps = Omit<HTMLAttributes<HTMLElement>, RestrictedApprovalCardAttribute> & {
-    /** Ordered questions. The card pages through them one at a time. */
-    questions: ApprovalQuestion[];
-    /** Optional heading above the question, e.g. the run the agent is planning. */
-    eyebrow?: ReactNode;
-    /** Controlled answers. Pair with `onAnswersChange`. */
-    answers?: ApprovalAnswers;
-    /** Initial answers when the card owns its own state. */
-    defaultAnswers?: ApprovalAnswers;
-    onAnswersChange?: (answers: ApprovalAnswers) => void;
-    /** Fired once the last question is confirmed. */
-    onComplete?: (answers: ApprovalAnswers) => void;
-    /** Fired when the scientist declines to answer and lets the agent decide. */
-    onSkip?: (answers: ApprovalAnswers) => void;
-    skipLabel?: string;
-    continueLabel?: string;
-    /** Label for the final page's primary action. */
-    completeLabel?: string;
-    /** Require a selection before the primary action enables. @default true */
-    requireAnswer?: boolean;
+    title: string;
+    mode: ApprovalCardMode;
+    options: readonly ApprovalCardOption[];
+};
+export type ApprovalCardAnswer = {
+    selectedOptionIds: readonly string[];
+    customValue: string;
+};
+export type ApprovalCardNavigationReason = "previous" | "next" | "continue" | "auto";
+export type ApprovalCardLabels = {
+    customAnswer: string;
+    previousQuestion: string;
+    nextQuestion: string;
+    skip: string;
+    continue: string;
+    submit: string;
+    submitting: string;
+};
+type NativeApprovalCardProps = Omit<FormHTMLAttributes<HTMLFormElement>, "children" | "onSubmit">;
+export type ApprovalQuestionCardProps = NativeApprovalCardProps & {
+    mode?: never;
+    questions: readonly ApprovalCardQuestion[];
+    activeQuestionId: string;
+    answers: Readonly<Record<string, ApprovalCardAnswer | undefined>>;
+    onAnswerChange: (questionId: string, answer: ApprovalCardAnswer) => void;
+    onActiveQuestionChange: (questionId: string, reason: ApprovalCardNavigationReason) => void;
+    onSubmit: (answers: Readonly<Record<string, ApprovalCardAnswer | undefined>>) => void;
+    onSkip?: (questionId: string) => void;
+    error?: string;
+    submitting?: boolean;
+    disabled?: boolean;
+    showSkip?: boolean;
+    autoAdvanceSingle?: boolean;
+    labels?: Partial<ApprovalCardLabels>;
+};
+export type ApprovalCardPermissionDecision = "deny" | "approve-once" | "approve-always";
+export type ApprovalCardPermissionLabels = {
+    deny: string;
+    approveOnce: string;
+    approveAlways: string;
+    approvalMenu: string;
+    submitting: string;
+};
+export type ApprovalCardPermissionProps = NativeApprovalCardProps & {
+    mode: "permission";
+    sourceLabel?: string;
+    title: string;
+    description?: string;
+    command?: string;
+    onDecision: (decision: ApprovalCardPermissionDecision) => void;
+    disabled?: boolean;
+    submitting?: boolean;
+    labels?: Partial<ApprovalCardPermissionLabels>;
+    menuOpen?: boolean;
+    defaultMenuOpen?: boolean;
+    onMenuOpenChange?: (open: boolean) => void;
+    portalContainer?: DropdownMenuContentProps["portalContainer"];
 };
-/**
- * Human-in-the-loop approval. The agent pauses, asks what it should do, and
- * waits: one question per page, a clear way out, and no hidden defaults.
- */
-export declare const ApprovalCard: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, RestrictedApprovalCardAttribute> & {
-    /** Ordered questions. The card pages through them one at a time. */
-    questions: ApprovalQuestion[];
-    /** Optional heading above the question, e.g. the run the agent is planning. */
-    eyebrow?: ReactNode;
-    /** Controlled answers. Pair with `onAnswersChange`. */
-    answers?: ApprovalAnswers;
-    /** Initial answers when the card owns its own state. */
-    defaultAnswers?: ApprovalAnswers;
-    onAnswersChange?: (answers: ApprovalAnswers) => void;
-    /** Fired once the last question is confirmed. */
-    onComplete?: (answers: ApprovalAnswers) => void;
-    /** Fired when the scientist declines to answer and lets the agent decide. */
-    onSkip?: (answers: ApprovalAnswers) => void;
-    skipLabel?: string;
-    continueLabel?: string;
-    /** Label for the final page's primary action. */
-    completeLabel?: string;
-    /** Require a selection before the primary action enables. @default true */
-    requireAnswer?: boolean;
-} & import("react").RefAttributes<HTMLElement>>;
+export type ApprovalCardProps = ApprovalQuestionCardProps | ApprovalCardPermissionProps;
+export declare const ApprovalCard: import("react").ForwardRefExoticComponent<ApprovalCardProps & import("react").RefAttributes<HTMLFormElement>>;
 export {};

package/dist/components/approval-plan-card/ApprovalPlanCard.d.ts

@@ -0,0 +1,28 @@
+import { type HTMLAttributes } from "react";
+import { type ApprovalPlan, type ApprovalPlanPhase, type ApprovalPlanStep, type ApprovalPlanSummary } from "./approvalPlanTypes";
+
+type NativeApprovalPlanCardProps = Omit<HTMLAttributes<HTMLElement>, "children" | "title">;
+type ApprovalPlanCardReadyProps = {
+    state?: "ready";
+    onReview: () => void;
+    onApprove: () => void;
+    approving?: boolean;
+};
+type ApprovalPlanCardRevisingProps = {
+    state: "revising";
+    onReview?: never;
+    onApprove?: never;
+    approving?: never;
+};
+export type ApprovalPlanCardProps = NativeApprovalPlanCardProps & (ApprovalPlanCardReadyProps | ApprovalPlanCardRevisingProps) & {
+    plan: ApprovalPlan;
+    disabled?: boolean;
+    reviewLabel?: string;
+    approveLabel?: string;
+};
+/**
+ * Compact execution-plan checkpoint for the Question flow. It intentionally
+ * summarizes phase names only; complete steps belong to ApprovalPlanReview.
+ */
+export declare const ApprovalPlanCard: import("react").ForwardRefExoticComponent<ApprovalPlanCardProps & import("react").RefAttributes<HTMLElement>>;
+export type { ApprovalPlan, ApprovalPlanPhase, ApprovalPlanStep, ApprovalPlanSummary, };

package/dist/components/approval-plan-card/approvalPlanTypes.d.ts

@@ -0,0 +1,35 @@
+export type ApprovalPlanStep = {
+    /** Stable identity within its phase. */
+    id: string;
+    /** Scannable action label. */
+    title: string;
+    /** Complete review copy; omitted from the approved compact record. */
+    description: string;
+};
+export type ApprovalPlanPhase = {
+    /** Stable identity within the plan. */
+    id: string;
+    /** Concise phase name. */
+    title: string;
+    /** Optional supporting classification such as Data acquisition. */
+    category?: string;
+    /** Ordered work within this phase. */
+    steps: readonly ApprovalPlanStep[];
+};
+export type ApprovalPlanSummary = {
+    scope: string;
+    dataSource: string;
+    outputs: string;
+};
+export type ApprovalPlan = {
+    /** Stable product-owned plan identity. */
+    id: string;
+    /** Full plan title used by the dedicated review surface. */
+    title: string;
+    /** Visible product-owned label, for example `Version 1`. */
+    version: string;
+    /** Ordered execution phases. */
+    phases: readonly ApprovalPlanPhase[];
+    summary: ApprovalPlanSummary;
+};
+export declare function assertApprovalPlan(plan: ApprovalPlan): void;

package/dist/components/command-search/CommandSearch.d.ts

@@ -13,6 +13,22 @@ export type CommandSearchItem = {
     onSelect?: (item: CommandSearchItem) => void;
     /** Removes the item from keyboard navigation and selection. */
     disabled?: boolean;
+    /**
+     * Opaque consumer payload, carried untouched through selection and
+     * `renderItem`. CommandSearch never reads it — it exists so a caller does not
+     * have to keep a parallel id-to-record map just to draw an icon or route a
+     * command.
+     */
+    data?: unknown;
+};
+/** State handed to `renderItem` for one row. */
+export type CommandSearchItemState = {
+    /** This row currently carries the roving highlight. */
+    active: boolean;
+    /** This row is not selectable and is skipped by keyboard navigation. */
+    disabled: boolean;
+    /** The live query, for a consumer highlighting its own text. */
+    query: string;
 };
 export type CommandSearchProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> & {
     items: readonly CommandSearchItem[];
@@ -31,11 +47,38 @@ export type CommandSearchProps = Omit<HTMLAttributes<HTMLDivElement>, "children"
     grouped?: boolean;
     /** Secondary line shown under the empty-state title. */
     emptyHint?: ReactNode;
+    /**
+     * Run the built-in label/group/hint substring filter. @default true
+     *
+     * Set `false` when the caller already filtered — an alias-aware catalog or a
+     * server content search, say. Every item then renders exactly as supplied
+     * and nothing is hidden, so a result that matched on something CommandSearch
+     * cannot see (an alias, a synonym, document body text) still appears. Match
+     * highlighting is unaffected: a label that happens to contain the query is
+     * still marked, and one that does not simply renders plain.
+     */
+    filter?: boolean;
+    /**
+     * Replaces the content of a row — icon, label, status, shortcut, whatever the
+     * surface needs. CommandSearch keeps ownership of the listbox and option
+     * semantics around it: ids, `role`, `aria-selected`, active handling, pointer
+     * and click wiring, and disabled skipping are all unchanged, so a custom row
+     * cannot break keyboard navigation.
+     *
+     * Default row content (marked label plus hint) is used when this is omitted.
+     */
+    renderItem?: (item: CommandSearchItem, state: CommandSearchItemState) => ReactNode;
 };
 /**
  * A command palette search surface. CommandSearch renders inline as an
  * embedded panel and can be composed inside a Dialog by the consumer; it owns
  * filtering, match highlighting, and roving keyboard selection only.
+ *
+ * Both halves of that are optional. A surface whose catalog already knows about
+ * aliases, or whose results come back from a server search, passes
+ * `filter={false}` and keeps the listbox semantics without the second,
+ * narrower filter running behind it. A surface needing richer rows than
+ * label-plus-hint passes `renderItem` and keeps the keyboard model.
  */
 export declare const CommandSearch: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> & {
     items: readonly CommandSearchItem[];
@@ -54,4 +97,25 @@ export declare const CommandSearch: import("react").ForwardRefExoticComponent<Om
     grouped?: boolean;
     /** Secondary line shown under the empty-state title. */
     emptyHint?: ReactNode;
+    /**
+     * Run the built-in label/group/hint substring filter. @default true
+     *
+     * Set `false` when the caller already filtered — an alias-aware catalog or a
+     * server content search, say. Every item then renders exactly as supplied
+     * and nothing is hidden, so a result that matched on something CommandSearch
+     * cannot see (an alias, a synonym, document body text) still appears. Match
+     * highlighting is unaffected: a label that happens to contain the query is
+     * still marked, and one that does not simply renders plain.
+     */
+    filter?: boolean;
+    /**
+     * Replaces the content of a row — icon, label, status, shortcut, whatever the
+     * surface needs. CommandSearch keeps ownership of the listbox and option
+     * semantics around it: ids, `role`, `aria-selected`, active handling, pointer
+     * and click wiring, and disabled skipping are all unchanged, so a custom row
+     * cannot break keyboard navigation.
+     *
+     * Default row content (marked label plus hint) is used when this is omitted.
+     */
+    renderItem?: (item: CommandSearchItem, state: CommandSearchItemState) => ReactNode;
 } & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/composer/Composer.d.ts

@@ -1,7 +1,10 @@
+import { type MouseEvent } from "react";
+import { type IconButtonProps } from "../icon-button/IconButton";
 
 export type ComposerMode = "guided" | "autopilot";
 export type ComposerStatus = "idle" | "sending" | "streaming";
 export type ComposerPreviewState = "hover" | "focus";
+export type ComposerAddButtonProps = Pick<IconButtonProps, "aria-controls" | "aria-expanded" | "aria-haspopup">;
 export type ComposerLabels = {
     input: string;
     add: string;
@@ -17,7 +20,11 @@ export type ComposerProps = {
     onValueChange?: (value: string) => void;
     onSubmitPrompt?: (value: string, mode: ComposerMode) => void;
     onStop?: () => void;
-    onAdd?: () => void;
+    onAdd?: (event: MouseEvent<HTMLButtonElement>) => void;
+    /** Menu relationship metadata when the existing Add action opens a popup. */
+    addButtonProps?: ComposerAddButtonProps;
+    /** Enables submission when consumer-owned content, such as files, is ready. */
+    submissionReady?: boolean;
     mode?: ComposerMode;
     defaultMode?: ComposerMode;
     onModeChange?: (mode: ComposerMode) => void;

package/dist/components/composer/ComposerUpload.d.ts

@@ -0,0 +1,65 @@
+import { type DragEventHandler } from "react";
+import { type UploadQueueAction, type UploadQueueResource, type UploadQueueStateLabels } from "../upload-queue/UploadQueue";
+import { type ComposerProps } from "./Composer";
+
+export type ComposerUploadProps = Omit<ComposerProps, "className" | "onAdd" | "submissionReady"> & {
+    /** Product-owned queue rendered above the Composer entry. */
+    items: readonly UploadQueueResource[];
+    /** Opens the product's native file or folder picker. */
+    onBrowse: () => void;
+    onRemove?: UploadQueueAction;
+    /** Clears every selected resource before upload begins. */
+    onClear?: () => void;
+    onCancel?: UploadQueueAction;
+    onRetry?: UploadQueueAction;
+    stateLabels?: Partial<UploadQueueStateLabels>;
+    announcement?: string;
+    /** Controlled active drop feedback. File traversal remains product-owned. */
+    dragging?: boolean;
+    /** Plays the approved final queue collapse before the product clears items. */
+    dismissing?: boolean;
+    onDrop?: DragEventHandler<HTMLDivElement>;
+    onDragEnter?: DragEventHandler<HTMLDivElement>;
+    onDragLeave?: DragEventHandler<HTMLDivElement>;
+    onDragOver?: DragEventHandler<HTMLDivElement>;
+    menuTitle?: string;
+    browseLabel?: string;
+    clearLabel?: string;
+    dragHint?: string;
+    dropLabel?: string;
+    className?: string;
+    composerClassName?: string;
+};
+/**
+ * Controlled Composer upload composition. It combines the production Composer,
+ * Dropdown Menu, and Upload Queue while leaving file traversal, transport, and
+ * lifecycle timing with the consuming product.
+ */
+export declare const ComposerUpload: import("react").ForwardRefExoticComponent<Omit<ComposerProps, "className" | "onAdd" | "submissionReady"> & {
+    /** Product-owned queue rendered above the Composer entry. */
+    items: readonly UploadQueueResource[];
+    /** Opens the product's native file or folder picker. */
+    onBrowse: () => void;
+    onRemove?: UploadQueueAction;
+    /** Clears every selected resource before upload begins. */
+    onClear?: () => void;
+    onCancel?: UploadQueueAction;
+    onRetry?: UploadQueueAction;
+    stateLabels?: Partial<UploadQueueStateLabels>;
+    announcement?: string;
+    /** Controlled active drop feedback. File traversal remains product-owned. */
+    dragging?: boolean;
+    /** Plays the approved final queue collapse before the product clears items. */
+    dismissing?: boolean;
+    onDrop?: DragEventHandler<HTMLDivElement>;
+    onDragEnter?: DragEventHandler<HTMLDivElement>;
+    onDragLeave?: DragEventHandler<HTMLDivElement>;
+    onDragOver?: DragEventHandler<HTMLDivElement>;
+    menuTitle?: string;
+    browseLabel?: string;
+    clearLabel?: string;
+    dragHint?: string;
+    dropLabel?: string;
+    className?: string;
+    composerClassName?: string;
+} & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/dot-field/DotField.d.ts

@@ -0,0 +1,102 @@
+import { type CSSProperties, type RefObject } from "react";
+
+/**
+ * A plain rectangle in the field's own coordinate space — CSS pixels measured
+ * from the top-left of the canvas, not from the viewport. Stored as a plain
+ * object rather than a `DOMRect` so the exclusion maths can be tested without
+ * a DOM.
+ */
+export interface DotFieldRect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * Spotlight falloff at `distance` from the pointer, in `[0, 1]`.
+ *
+ * Quadratic rather than linear: the brightened region reads as a soft pool of
+ * light with no visible rim, because the derivative goes to zero at the edge.
+ * `0` at and beyond `radius`, `1` exactly under the pointer.
+ *
+ * A non-positive radius disables the spotlight entirely rather than dividing
+ * by zero.
+ */
+export declare function dotFieldFalloff(distance: number, radius: number): number;
+/** Grow a rectangle equally on all sides. */
+export declare function dotFieldInflateRect(rect: DotFieldRect, padding: number): DotFieldRect;
+/**
+ * Shortest distance from a point to a rectangle. Zero when the point is inside
+ * or on the boundary.
+ */
+export declare function dotFieldDistanceToRect(x: number, y: number, rect: DotFieldRect): number;
+/**
+ * How much of a dot survives the exclusion halo, in `[0, 1]`.
+ *
+ * `0` anywhere inside an already-inflated rect — no dot is drawn at all — then
+ * a linear ramp back to `1` over `feather` pixels outside it, so the halo has
+ * no hard cut. With several rects the smallest value wins, which is what makes
+ * overlapping halos merge into one hole instead of cancelling each other out.
+ *
+ * Rects are expected pre-inflated; `dotFieldInflateRect` does that separately
+ * so the padding is applied once per layout rather than once per dot.
+ */
+export declare function dotFieldExclusionAlpha(x: number, y: number, rects: readonly DotFieldRect[], feather: number): number;
+export interface DotFieldProps {
+    /** Lattice pitch in CSS pixels. @default 24 */
+    spacing?: number;
+    /** Radius of a resting dot in CSS pixels. @default 0.5 */
+    dotRadius?: number;
+    /** Opacity of the resting lattice. @default 0.14 */
+    baseAlpha?: number;
+    /** Opacity directly under the pointer. @default 0.75 */
+    peakAlpha?: number;
+    /** Spotlight reach in CSS pixels. @default 180 */
+    radius?: number;
+    /** Dot scale directly under the pointer. @default 2.6 */
+    peakScale?: number;
+    /**
+     * Element whose pointer movement drives the field. Defaults to the host's
+     * own parent, which is the common case: the field is the background layer of
+     * the section it reacts to.
+     */
+    containerRef?: RefObject<HTMLElement | null>;
+    /**
+     * Element the lattice makes room for. Its bounding box, inflated by
+     * `exclusionPadding` and feathered, renders no dots. One element means one
+     * collective halo, however many children it wraps.
+     */
+    exclusionRef?: RefObject<HTMLElement | null>;
+    /**
+     * Static exclusion rects in the field's own coordinate space, as an
+     * alternative to `exclusionRef`. Combined with it when both are given.
+     */
+    exclusionRects?: readonly DotFieldRect[];
+    /** Inflation applied to every exclusion rect. @default 24 */
+    exclusionPadding?: number;
+    /** Alpha ramp width at the exclusion edge. @default 40 */
+    exclusionFeather?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+/**
+ * Cursor-reactive dot lattice, as a full-bleed background layer.
+ *
+ * At rest it is a dim monotone grid of dots. Under the pointer a soft pool of
+ * light brightens and enlarges the dots it covers, trailing the cursor by a
+ * frame or two so the surface feels physical rather than pinned. An optional
+ * exclusion element punches a feathered hole in the lattice, so content
+ * floating above the field keeps a clean field of its own.
+ *
+ * Performance: the resting lattice is rasterised once to an offscreen canvas
+ * and blitted each frame, so per-frame work is bounded by the spotlight's
+ * footprint (a few hundred dots) rather than the page's (several thousand).
+ * The rAF loop runs only while the pointer is inside and until the eased
+ * pointer settles; an untouched field costs nothing.
+ *
+ * Colour is resolved from `--color-foreground` at draw time and re-resolved
+ * when `data-theme` changes, so the field is monotone and correct in both
+ * themes without a theme prop. It is decorative: `aria-hidden` and inert to
+ * pointer events.
+ */
+export declare function DotField({ spacing, dotRadius, baseAlpha, peakAlpha, radius, peakScale, containerRef, exclusionRef, exclusionRects, exclusionPadding, exclusionFeather, className, style, }: DotFieldProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/dropdown-menu/DropdownMenu.d.ts

@@ -33,6 +33,8 @@ export type DropdownMenuContentProps = Omit<ComponentPropsWithoutRef<typeof Menu
     finalFocus?: ComponentPropsWithoutRef<typeof Menu.Popup>["finalFocus"];
     /** Accessible name when no visible group label names the menu. */
     "aria-label"?: string;
+    /** Stable id applied to the role=menu popup for external trigger relationships. */
+    popupId?: string;
 };
 /**
  * Portalled, collision-aware menu surface. Trigger styling remains external.
@@ -55,6 +57,8 @@ export declare const DropdownMenuContent: import("react").ForwardRefExoticCompon
     finalFocus?: ComponentPropsWithoutRef<typeof Menu.Popup>["finalFocus"];
     /** Accessible name when no visible group label names the menu. */
     "aria-label"?: string;
+    /** Stable id applied to the role=menu popup for external trigger relationships. */
+    popupId?: string;
 } & import("react").RefAttributes<HTMLDivElement>>;
 export type DropdownMenuGroupProps = Omit<ComponentPropsWithoutRef<typeof Menu.Group>, "className"> & {
     className?: string;

package/dist/components/explorer/Explorer.d.ts

@@ -1,7 +1,8 @@
 import { type HTMLAttributes, type MouseEvent, type MouseEventHandler, type ReactNode } from "react";
+import { type ScientificOutputResourceType, type UploadResourceType } from "../../internal/ResourceTypeIcon";
 
-export type ExplorerUploadFileType = "data" | "structured-data" | "document" | "code" | "notebook" | "image" | "scientific-data" | "archive" | "generic";
-export type ExplorerScientificOutputType = "dataset" | "report" | "figure" | "plot" | "code" | "generic";
+export type ExplorerUploadFileType = UploadResourceType;
+export type ExplorerScientificOutputType = ScientificOutputResourceType;
 type ExplorerResourceBase = {
     /** Stable owner-defined identity. IDs are unique across the whole Explorer. */
     id: string;

package/dist/components/file-dropzone/FileDropzone.d.ts

@@ -12,6 +12,7 @@ export type FileDropzoneRejection = {
     message: string;
 };
 export type FileDropzoneState = "default" | "drag-active" | "drag-rejected" | "disabled" | "selection-received";
+export type FileDropzoneDensity = "default" | "compact";
 export type FileDropzoneHandle = {
     browseFiles: () => void;
     browseFolder: () => void;
@@ -27,6 +28,14 @@ export type FileDropzoneProps = Omit<HTMLAttributes<HTMLDivElement>, "children"
     maxFiles?: number;
     maxFileSize?: number;
     disabled?: boolean;
+    /** Default is the standalone acquisition surface; compact pairs with a visible Upload Queue. */
+    density?: FileDropzoneDensity;
+    /** Mirrors a consumer-owned selected-resource collection into the settled visual state. */
+    hasSelection?: boolean;
+    /** Settled-state action label. State feedback temporarily replaces it while dragging. */
+    actionLabel?: string;
+    /** Settled-state helper copy. State feedback temporarily replaces it while dragging. */
+    helperText?: string;
     onSelection?: (selection: FileDropzoneSelection) => void;
     onReject?: (rejection: FileDropzoneRejection) => void;
     /** Review-only state hook used by Storybook and visual regression tests. */
@@ -47,6 +56,14 @@ export declare const FileDropzone: import("react").ForwardRefExoticComponent<Omi
     maxFiles?: number;
     maxFileSize?: number;
     disabled?: boolean;
+    /** Default is the standalone acquisition surface; compact pairs with a visible Upload Queue. */
+    density?: FileDropzoneDensity;
+    /** Mirrors a consumer-owned selected-resource collection into the settled visual state. */
+    hasSelection?: boolean;
+    /** Settled-state action label. State feedback temporarily replaces it while dragging. */
+    actionLabel?: string;
+    /** Settled-state helper copy. State feedback temporarily replaces it while dragging. */
+    helperText?: string;
     onSelection?: (selection: FileDropzoneSelection) => void;
     onReject?: (rejection: FileDropzoneRejection) => void;
     /** Review-only state hook used by Storybook and visual regression tests. */