@arbidocs/blocks 0.3.185 → 0.4.0

package/dist/files/HtmlViewerParts.d.ts

@@ -0,0 +1,183 @@
+import type { ReactNode, Ref } from 'react';
+/** Every fixed string of the parsed viewer parts. Pass a partial `labels` to translate or reword. */
+export interface HtmlViewerLabels {
+    viewerRegion: string;
+    pageOfTotal: (page: number, total: number) => string;
+    documentContent: string;
+    page: (n: number) => string;
+    noContent: string;
+    noContentDescription: string;
+    citedSuffix: string;
+    previousCited: string;
+    nextCited: string;
+    previousLabelPassage: string;
+    nextLabelPassage: string;
+    sharedWithMembers: string;
+    privateToYou: string;
+    shared: string;
+    private: string;
+    instantTranslation: string;
+    backToDocument: string;
+    compareOriginal: string;
+    copyComparison: string;
+    copyTranslation: string;
+    passage: string;
+    original: string;
+    translation: string;
+}
+export declare const DEFAULT_HTML_VIEWER_LABELS: HtmlViewerLabels;
+export interface HtmlViewerRootProps {
+    children: ReactNode;
+    className?: string;
+}
+/** Positioning context for the parsed viewer: overlays (tag bar, cited stepper) sit on it. */
+export declare function HtmlViewerRoot({ children, className }: HtmlViewerRootProps): import("react").JSX.Element;
+export interface HtmlViewerSurfaceProps {
+    children: ReactNode;
+    surfaceRef?: Ref<HTMLDivElement>;
+    /** Hidden (kept mounted) while the translation comparison table is showing. */
+    hidden?: boolean;
+    onMouseUp?: () => void;
+    className?: string;
+    labels?: Partial<HtmlViewerLabels>;
+    /** Overrides the root test id (default `parsed-viewer`). */
+    testId?: string;
+}
+/** The scrolling canvas the page sheets stack on. */
+export declare function HtmlViewerSurface({ children, surfaceRef, hidden, onMouseUp, className, labels, testId, }: HtmlViewerSurfaceProps): import("react").JSX.Element;
+export interface HtmlPageProps {
+    /** 1-based page number, null for unpaginated content. */
+    pageNumber: number | null;
+    totalPages: number;
+    /** False renders a sized placeholder (lazy pages). */
+    isRendered: boolean;
+    /** Placeholder height in px when not rendered. */
+    placeholderHeight: number;
+    /** Text size multiplier: the font size changes and the text reflows inside the page width. */
+    zoom?: number;
+    children?: ReactNode;
+    labels?: Partial<HtmlViewerLabels>;
+}
+/** One page sheet: numbered header, content, or a lightweight placeholder while off-screen. */
+export declare function HtmlPage({ pageNumber, totalPages, isRendered, placeholderHeight, zoom, children, labels, }: HtmlPageProps): import("react").JSX.Element;
+/** Shown when a parsed document has no chunks. */
+export declare function HtmlViewerEmpty({ labels }: {
+    labels?: Partial<HtmlViewerLabels>;
+}): import("react").JSX.Element;
+export type PassageHighlight = 'light' | 'strong';
+export interface HtmlPassageProps {
+    /** Passage (chunk) id: the element id, deep-link and scroll target. */
+    chunkId?: string;
+    /** Yellow wash: `strong` = selected/being read, `light` = listed or search hit. */
+    highlight?: PassageHighlight;
+    /** Marks a search hit for e2e (`highlighted-chunk`). */
+    isHit?: boolean;
+    /** Overrides the hit test id (default `highlighted-chunk`). */
+    hitTestId?: string;
+    /** Part of a contiguous selected run; the run is drawn as one block. */
+    isSelected?: boolean;
+    runIsStart?: boolean;
+    runIsEnd?: boolean;
+    /** Citation mode: the passage toggles on click. */
+    isClickable?: boolean;
+    /** Click on the passage; `extend` is true when shift was held (range select). */
+    onSelect?: (extend: boolean) => void;
+    /** The passage carries labels; `tagMark` draws them. */
+    isTagged?: boolean;
+    /** Colour of the label currently being walked, when it marks this passage. */
+    activeTagColor?: string;
+    /** Citation run marker, shown once at the first member of a run. */
+    runMarker?: ReactNode;
+    /** Label stripes in the margin (a `LabelMark`): always visible, one menu. */
+    tagMark?: ReactNode;
+    /**
+     * The passage's reference mark (a `PassageMark`): quiet text in the margin whose menu carries
+     * every passage action. Faint on hover/focus, always faintly visible on touch.
+     */
+    mark?: ReactNode;
+    /** The passage text. */
+    children: ReactNode;
+}
+/** One parsed passage: highlight states, label stripes, run marker, reference label, actions. */
+export declare const HtmlPassage: import("react").NamedExoticComponent<HtmlPassageProps>;
+export interface PassageStepperProps {
+    /** 1-based position. */
+    position: number;
+    total: number;
+    onStep: (delta: number) => void;
+    /** Test id of the stepper (none by default). */
+    testId?: string;
+    className?: string;
+    prevLabel: string;
+    nextLabel: string;
+    /** Text after the count, e.g. "cited". */
+    suffix?: string;
+}
+/** Compact "3/9 cited" prev/next stepper overlaid on the document. */
+export declare function PassageStepper({ position, total, onStep, testId, className, prevLabel, nextLabel, suffix, }: PassageStepperProps): import("react").JSX.Element;
+/** Overlay placement for the cited-passages stepper (top centre of the viewer). */
+export declare function CitedRunNav({ labels, testId, ...props }: Omit<PassageStepperProps, 'prevLabel' | 'nextLabel' | 'testId' | 'suffix'> & {
+    labels?: Partial<HtmlViewerLabels>;
+    /** Overrides the stepper test id (default `note-run-nav`). */
+    testId?: string;
+}): import("react").JSX.Element;
+export interface DocTagChipView {
+    id: string;
+    name: string;
+    /** Fill colour (dynamic, per label). */
+    color: string;
+    /** Passages the label marks; 0 = applies to the whole document. */
+    passageCount: number;
+    hasNote: boolean;
+    title: string;
+}
+export interface DocTagBarProps {
+    chips: DocTagChipView[];
+    /** Document visibility mark on the far right; null/undefined omits it. */
+    visibility?: 'shared' | 'private' | null;
+    /** Passage stepping over the active label's passages (parsed view only). */
+    step?: {
+        position: number;
+        total: number;
+        onStep: (delta: number) => void;
+    };
+    /** The label currently washing its passages (parsed view only). */
+    activeId?: string | null;
+    /** When given, chips are toggles: pick a label to mark its passages, pick it again to clear. */
+    onSelect?: (id: string | null) => void;
+    labels?: Partial<HtmlViewerLabels>;
+    testIds?: Partial<DocTagBarTestIds>;
+}
+export interface DocTagBarTestIds {
+    root: string;
+    nav: string;
+    visibility: string;
+    /** Replaces the whole `doc-tag-chip-<id>` id. */
+    chip: (id: string) => string;
+}
+/**
+ * The document's labels along the top of a viewer: chips (toggles when `onSelect` is given, else
+ * read-only marks), optional passage stepper for the active label, and the shared/private mark.
+ * Draws nothing when it has nothing to say.
+ */
+export declare function DocTagBar({ chips, visibility, step, activeId, onSelect, labels, testIds, }: DocTagBarProps): import("react").JSX.Element | null;
+export interface TranslationBadgeProps {
+    isComparing: boolean;
+    onToggleCompare: () => void;
+    onCopy: () => Promise<void>;
+    labels?: Partial<HtmlViewerLabels>;
+}
+/** "Instant Translation" chip with compare toggle and copy. */
+export declare function TranslationBadge({ isComparing, onToggleCompare, onCopy, labels, }: TranslationBadgeProps): import("react").JSX.Element;
+export interface TranslationRowView {
+    key: string;
+    /** The passage reference pill (host renders its entity). */
+    passage: ReactNode;
+    original: string;
+    translated: string;
+}
+/** Passage / Original / Translation table. */
+export declare function TranslationCompareTable({ rows, labels, }: {
+    rows: TranslationRowView[];
+    labels?: Partial<HtmlViewerLabels>;
+}): import("react").JSX.Element;

package/dist/files/MoveToFolderDialog.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the dialog. Pass a partial `labels` to translate or reword. */
+export interface MoveToFolderLabels {
+    title: string;
+    cancel: string;
+    move: string;
+    moving: string;
+}
+export declare const DEFAULT_MOVE_TO_FOLDER_LABELS: MoveToFolderLabels;
+export interface MoveToFolderTestIds {
+    modal: string;
+    cancel: string;
+    confirm: string;
+}
+export interface MoveToFolderDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** What is being moved, shown as a badge: a folder name or "3 selected". */
+    subject: string;
+    /** Screen-reader description. */
+    description: string;
+    /** The folder picker (the host owns the folder tree and search). */
+    children: ReactNode;
+    canConfirm: boolean;
+    isSubmitting?: boolean;
+    onConfirm: () => void;
+    labels?: Partial<MoveToFolderLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<MoveToFolderTestIds>;
+}
+/** "Move to folder" dialog shell: header with subject badge, picker slot, Cancel + Move. */
+export declare function MoveToFolderDialog({ open, onClose, subject, description, children, canConfirm, isSubmitting, onConfirm, labels, testIds, }: MoveToFolderDialogProps): import("react").JSX.Element;

package/dist/files/RedlineParts.d.ts

@@ -0,0 +1,72 @@
+import type { ComponentPropsWithoutRef, ReactNode, Ref } from 'react';
+/** Every fixed string of the redline parts. Pass a partial `labels` to translate or reword. */
+export interface RedlineLabels {
+    flipComparison: string;
+    noDocument: string;
+    noChangesYet: string;
+    identical: string;
+    unavailable: string;
+    revertMove: string;
+    revertReplace: string;
+    revertAdd: string;
+    revertRemove: string;
+}
+export declare const DEFAULT_REDLINE_LABELS: RedlineLabels;
+export type RedlineRegionKind = 'replace' | 'remove' | 'add' | 'move';
+export interface RedlineFrameProps {
+    /** Optional header row (see RedlineHeader). */
+    header?: ReactNode;
+    children: ReactNode;
+}
+/** Column shell for a redline: optional header, scrolling body. */
+export declare function RedlineFrame({ header, children }: RedlineFrameProps): import("react").JSX.Element;
+export interface RedlineHeaderProps {
+    /** The base document pill. */
+    base: ReactNode;
+    /** The compared document pill. */
+    compare?: ReactNode;
+    onFlip: () => void;
+    labels?: Partial<RedlineLabels>;
+}
+/** "Base ⇄ Compare" row with the flip control. */
+export declare function RedlineHeader({ base, compare, onFlip, labels }: RedlineHeaderProps): import("react").JSX.Element;
+export type RedlineStatusKind = 'idle' | 'identical' | 'unavailable';
+/** A centred status line for the redline body (nothing to diff). */
+export declare function RedlineStatus({ kind, reviewMode, labels, }: {
+    kind: RedlineStatusKind;
+    /** Accept/reject mode: "identical" means no edits yet. */
+    reviewMode?: boolean;
+    labels?: Partial<RedlineLabels>;
+}): import("react").JSX.Element;
+/** Centres a loading indicator while the diff computes. */
+export declare function RedlineComputing({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface RedlineDocumentProps {
+    /** Rendered redline markdown. */
+    children: ReactNode;
+    /** Ref to the rendered body (the host measures change positions from it). */
+    bodyRef?: Ref<HTMLDivElement>;
+    /** Margin gutter (revert buttons) shown in accept/reject mode. */
+    gutter?: ReactNode;
+}
+export declare function RedlineDocument({ children, bodyRef, gutter }: RedlineDocumentProps): import("react").JSX.Element;
+/** `<del>` / `<ins>` for the markdown renderer: red strike, blue underline, green for moves. */
+export declare function RedlineMark({ as: Tag, isMove, children, ...props }: (ComponentPropsWithoutRef<'del'> | ComponentPropsWithoutRef<'ins'>) & {
+    as: 'del' | 'ins';
+    isMove: boolean;
+}): import("react").JSX.Element;
+export interface RedlineMarkerView {
+    cid: string;
+    /** Vertical offset in px, already spaced so buttons never overlap. */
+    top: number;
+    kind: RedlineRegionKind;
+}
+/** One undo button per change, aligned with the change in the margin. */
+export declare function RedlineRevertGutter({ markers, onRevert, labels, testId, }: {
+    markers: RedlineMarkerView[];
+    onRevert: (cid: string) => void;
+    labels?: Partial<RedlineLabels>;
+    /** Replaces the whole `redline-revert-<cid>` id. */
+    testId?: (cid: string) => string;
+}): import("react").JSX.Element | null;

package/dist/files/SelectionBar.d.ts

@@ -0,0 +1,65 @@
+import type { ReactNode } from 'react';
+import type { LucideIcon } from 'lucide-react';
+export interface SelectionBarActionItem {
+    id: string;
+    icon: LucideIcon;
+    label: string;
+    onClick: () => void;
+    disabled?: boolean;
+    variant?: 'default' | 'outline' | 'destructive' | 'ghost' | 'secondary';
+    /** Tooltip text; falls back to `label`. */
+    tooltip?: string;
+    testId?: string;
+    className?: string;
+}
+/** Every fixed string of the selection bar. Pass a partial `labels` to translate or reword. */
+export interface SelectionBarLabels {
+    selected: string;
+    clearSelection: string;
+    review: string;
+    selectionActions: string;
+}
+export declare const DEFAULT_SELECTION_BAR_LABELS: SelectionBarLabels;
+export interface SelectionBarTestIds {
+    toolbar: string;
+    count: string;
+    clear: string;
+    review: string;
+}
+export interface SelectionBarProps {
+    /** Number of selected rows. The bar renders only while this is > 0 (or `status` is set). */
+    count: number;
+    onClear: () => void;
+    /** Primary-in-bar "Review" shortcut (tonal, not the view's filled primary). */
+    onReview?: () => void;
+    /** Actions as data. Rendered icon-only automatically when the bar is narrow. */
+    actions?: SelectionBarActionItem[];
+    /**
+     * Free-form actions; a function receives `isCompact` (icon-only) and `isNarrow` (a phone-width
+     * container: fold secondary actions into an overflow menu). Rendered after `actions`.
+     */
+    children?: ReactNode | ((isCompact: boolean, isNarrow: boolean) => ReactNode);
+    /** Always-legible content before the actions (e.g. a running budget); never dimmed. */
+    status?: ReactNode;
+    /** Singular noun shown after the count; wins over `labels.selected`. */
+    selectedLabel?: string;
+    labels?: Partial<SelectionBarLabels>;
+    /** Overrides for the control test ids (defaults keep the current ids). */
+    testIds?: Partial<SelectionBarTestIds>;
+    className?: string;
+}
+/**
+ * SelectionBar: the floating bar that appears while rows are selected.
+ *
+ * Stays on ONE row: when the actions overflow it flips to compact mode (icon-only actions and a
+ * count-only badge) instead of wrapping. Sticky zero-height anchor, so showing/hiding it never
+ * reflows the content beneath. Every control is always visible (nothing hover-only) and 44px on
+ * coarse pointers.
+ */
+export declare function SelectionBar(props: SelectionBarProps): import("react").JSX.Element | null;
+export interface SelectionBarActionProps extends Omit<SelectionBarActionItem, 'id'> {
+    /** Icon-only (the bar passes this when narrow). */
+    isCompact?: boolean;
+}
+/** One action button in the bar: icon + label, icon-only when compact, always with a tooltip. */
+export declare function SelectionBarAction({ icon: Icon, label, onClick, disabled, variant, tooltip, testId, className, isCompact, }: SelectionBarActionProps): import("react").JSX.Element;

package/dist/files/StatusPill.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+import { type Tone } from '../components/tones';
+/** The shared tone vocabulary (see `components/tones`). */
+export type StatusTone = Tone;
+export interface StatusPillProps {
+    tone?: StatusTone;
+    /** Leading glyph. With no `label` the pill is a glyph-only chip. */
+    icon?: ReactNode;
+    label?: ReactNode;
+    /** Adds a thin bar under the label (queued = still, processing = animated). */
+    progress?: 'queued' | 'processing';
+    /** Native tooltip and accessible name for glyph-only pills. */
+    title?: string;
+    /** Makes the pill a button (stops row-click propagation). */
+    onClick?: () => void;
+    testId?: string;
+    className?: string;
+}
+/**
+ * A small tinted status chip. Source-agnostic: the host decides tone, glyph and copy from its
+ * own status model; the block only owns the look, the touch target and the keyboard path.
+ */
+export declare function StatusPill({ tone, icon, label, progress, title, onClick, testId, className, }: StatusPillProps): import("react").JSX.Element;

package/dist/files/TagPassagePanel.d.ts

@@ -0,0 +1,60 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the panel. Pass a partial `labels` to translate or reword. */
+export interface TagPassagePanelLabels {
+    title: string;
+    page: (n: number) => string;
+    close: string;
+    empty: string;
+    viewTagged: string;
+    notePlaceholder: string;
+    cancel: string;
+    save: string;
+    addNote: string;
+    createField: string;
+}
+export declare const DEFAULT_TAG_PASSAGE_PANEL_LABELS: TagPassagePanelLabels;
+export interface TagPassagePanelTestIds {
+    root: string;
+    close: string;
+    viewTagged: string;
+}
+export interface PassageTagRowView {
+    id: string;
+    /** Fill colour of the checkbox (dynamic, per label). */
+    color: string;
+    isApplied: boolean;
+    /** The tag badge (host renders its entity). */
+    badge: ReactNode;
+    /** The saved note on this passage's application of the tag. */
+    note?: string | null;
+}
+export interface PassageTagGroupView {
+    id: string;
+    title: string;
+    tags: PassageTagRowView[];
+}
+export interface TagPassagePanelProps {
+    pageNumber?: number;
+    /** Truncated passage text shown under the header. */
+    preview: string;
+    groups: PassageTagGroupView[];
+    /** No tags exist yet (shows the empty state). */
+    isEmpty: boolean;
+    isBusy: boolean;
+    /** The tag whose note is open for editing, and its draft. */
+    editingNoteTagId: string | null;
+    noteValue: string;
+    onNoteChange: (value: string) => void;
+    onToggle: (tagId: string) => void;
+    onViewTagged?: (tagId: string) => void;
+    onStartNote: (tagId: string) => void;
+    onSaveNote: (tagId: string) => void;
+    onCancelNote: () => void;
+    onCreate: () => void;
+    onClose: () => void;
+    labels?: Partial<TagPassagePanelLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<TagPassagePanelTestIds>;
+}
+/** Side panel to apply labels (and per-passage notes) to one passage of a document. */
+export declare function TagPassagePanel({ pageNumber, preview, groups, isEmpty, isBusy, editingNoteTagId, noteValue, onNoteChange, onToggle, onViewTagged, onStartNote, onSaveNote, onCancelNote, onCreate, onClose, labels, testIds, }: TagPassagePanelProps): import("react").JSX.Element;

package/dist/files/UploadDropzone.d.ts

@@ -0,0 +1,33 @@
+import type { LucideIcon } from 'lucide-react';
+export interface UploadDropzoneProps {
+    /** Called with the chosen/dropped files. */
+    onFiles: (files: File[]) => void;
+    /** `accept` attribute for the file picker (e.g. `.pdf,.docx`). */
+    accept?: string;
+    /** Allow selecting more than one file. Defaults to true. */
+    multiple?: boolean;
+    /** Disables picking/dropping (e.g. no active workspace yet). */
+    disabled?: boolean;
+    /** Shows a spinner + busy copy while an upload is in flight. */
+    uploading?: boolean;
+    /** Primary line, e.g. "Drag files here". */
+    title?: string;
+    /** Secondary line under the title. */
+    description?: string;
+    /** Small muted hint, e.g. "PDF, DOCX, images — up to 50MB". */
+    hint?: string;
+    /** Copy shown next to the spinner while uploading. */
+    uploadingLabel?: string;
+    /** Glyph in the tile. Defaults to an upload-cloud icon. */
+    icon?: LucideIcon;
+    testId?: string;
+    className?: string;
+}
+/**
+ * A themeable drag-and-drop upload target. Source-agnostic: it just surfaces
+ * chosen files via `onFiles` — the host owns the actual upload. Handles its own
+ * drag-over state, click-to-browse, and a busy state, styled with the kit's
+ * SEMANTIC tokens only (border, muted, primary, foreground) so it renders in
+ * each host's colours.
+ */
+export declare function UploadDropzone({ onFiles, accept, multiple, disabled, uploading, title, description, hint, uploadingLabel, icon: Icon, testId, className, }: UploadDropzoneProps): import("react").JSX.Element;

package/dist/files/UploadFooter.d.ts

@@ -0,0 +1,59 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the upload footer. Pass a partial `labels` to translate or reword. */
+export interface UploadFooterLabels {
+    skipDuplicates: string;
+    skipDuplicatesActive: string;
+    skipDuplicatesInactive: string;
+    autoRename: string;
+    autoRenameActive: string;
+    autoRenameInactive: string;
+    titleInstruction: string;
+    titleInstructionPlaceholder: string;
+}
+export declare const DEFAULT_UPLOAD_FOOTER_LABELS: UploadFooterLabels;
+export interface UploadFooterTestIds {
+    bar: string;
+    skipDuplicates: string;
+    autoRename: string;
+    settingsPanel: string;
+    instruction: string;
+}
+export declare function UploadContainer({ children, className, testId, }: {
+    children: ReactNode;
+    className?: string;
+    /** Overrides the root test id (default `upload-container`). */
+    testId?: string;
+}): import("react").JSX.Element;
+export interface UploadShareNoteProps {
+    /** What the current choice means, e.g. "Uploaded documents will be shared with this workspace". */
+    description: string;
+    /** The visibility toggle itself (the host owns it). */
+    children: ReactNode;
+    /** Compact: a tooltip on the toggle. Otherwise a tonal card with the text beneath it. */
+    compact?: boolean;
+    /** Overrides the wrapper test id (default `share-toggle`). */
+    testId?: string;
+}
+/** Wraps the upload visibility toggle with its explanation (tooltip when compact, text otherwise). */
+export declare function UploadShareNote({ description, children, compact, testId, }: UploadShareNoteProps): import("react").JSX.Element;
+export interface UploadFooterBarProps {
+    skipDuplicates: boolean;
+    onSkipDuplicatesChange: (value: boolean) => void;
+    autoRename: boolean;
+    onAutoRenameChange: (value: boolean) => void;
+    autoRenameInstruction: string;
+    onAutoRenameInstructionChange: (value: string) => void;
+    /** The visibility toggle, right-aligned before the submit button. */
+    shareToggle?: ReactNode;
+    /** The Upload submit button (the view's ONE primary action). */
+    children: ReactNode;
+    className?: string;
+    labels?: Partial<UploadFooterLabels>;
+    testIds?: Partial<UploadFooterTestIds>;
+}
+/**
+ * The upload action footer: everyday toggles next to the submit button
+ * (`[Skip duplicates] [Auto-rename] ... [Visibility] [Upload N]`). When Auto-rename is on, its
+ * title instruction drops in just below.
+ */
+export declare function UploadFooterBar({ skipDuplicates, onSkipDuplicatesChange, autoRename, onAutoRenameChange, autoRenameInstruction, onAutoRenameInstructionChange, shareToggle, children, className, labels, testIds, }: UploadFooterBarProps): import("react").JSX.Element;

package/dist/files/UploadParts.d.ts

@@ -0,0 +1,78 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the upload parts. Pass a partial `labels` to translate or reword. */
+export interface UploadPartsLabels {
+    /** Heading per rejection reason (`too_large`, `unsupported`, `empty`, `no_extension`, `empty_zip`, `zip_error`). */
+    rejectedReasons: Record<string, string>;
+    rejectedFallback: string;
+    clearRejected: string;
+    selectedFiles: (count: number) => string;
+    total: (size: string) => string;
+    clearAll: string;
+    remove: (fileName: string) => string;
+    uploadComplete: (entity: string) => string;
+    uploading: (count: number, entity: string) => string;
+    uploadedIndexing: string;
+    afterUpload: string;
+}
+export declare const DEFAULT_UPLOAD_PARTS_LABELS: UploadPartsLabels;
+/** Compact tinted error for the upload flow (status tone, not a boxed banner). */
+export declare function UploadErrorMessage({ message, className, testId, }: {
+    message: string;
+    className?: string;
+    /** Overrides the root test id (default `error-message`). */
+    testId?: string;
+}): import("react").JSX.Element;
+export interface RejectedFile {
+    name: string;
+    reason?: string;
+}
+export interface RejectedFilesListProps {
+    /** Plain names are treated as "unsupported". */
+    files: (string | RejectedFile)[];
+    onClear: () => void;
+    labels?: Partial<UploadPartsLabels>;
+    testIds?: Partial<RejectedFilesTestIds>;
+}
+export interface RejectedFilesTestIds {
+    root: string;
+    clear: string;
+    /** Replaces the whole `rejected-file-item-<group>-<index>` id. */
+    item: (groupIndex: number, index: number) => string;
+}
+/** Files that cannot be uploaded, grouped by rejection reason. */
+export declare function RejectedFilesList({ files, onClear, labels, testIds }: RejectedFilesListProps): import("react").JSX.Element | null;
+export interface SelectedFilesListProps {
+    files: File[];
+    onRemoveFile: (index: number) => void;
+    onClearAll?: () => void;
+    formatFileSize: (bytes: number) => string;
+    /** File-type glyph for a file name (the host owns its icon set). */
+    renderFileIcon: (fileName: string) => ReactNode;
+    labels?: Partial<UploadPartsLabels>;
+    testIds?: Partial<SelectedFilesTestIds>;
+}
+export interface SelectedFilesTestIds {
+    root: string;
+    clearAll: string;
+    /** Replaces the whole `selected-file-item-<index>` id. */
+    item: (index: number) => string;
+    /** Replaces the whole `remove-file-button-<index>` id. */
+    remove: (index: number) => string;
+}
+/** The files chosen for upload, with total size, per-file remove and Clear All. */
+export declare function SelectedFilesList({ files, onRemoveFile, onClearAll, formatFileSize, renderFileIcon, labels, testIds, }: SelectedFilesListProps): import("react").JSX.Element | null;
+export interface UploadProgressProps {
+    fileCount: number;
+    entityLabel: string;
+    percentage: number;
+    /** Multi-batch uploads draw a tick between batches on the bar. */
+    batchInfo?: {
+        current: number;
+        total: number;
+    } | null;
+    labels?: Partial<UploadPartsLabels>;
+    /** Overrides the root test id (default `upload-progress`). */
+    testId?: string;
+}
+/** Determinate upload bar with the copy for in-flight and complete states. */
+export declare function UploadProgress({ fileCount, entityLabel, percentage, batchInfo, labels, testId, }: UploadProgressProps): import("react").JSX.Element;