@arbidocs/blocks 0.3.185 → 0.4.0

package/dist/files/UploadSources.d.ts

@@ -0,0 +1,77 @@
+import type { DragEventHandler, MouseEventHandler, ReactNode } from 'react';
+/** Every fixed string of the upload source parts. */
+export interface UploadSourcesLabels {
+    uploadFiles: string;
+    uploadFolder: string;
+}
+export declare const DEFAULT_UPLOAD_SOURCES_LABELS: UploadSourcesLabels;
+export interface UploadFrameProps {
+    isCompact?: boolean;
+    /** Dimmed while disabled or while files are being processed. */
+    isDimmed?: boolean;
+    className?: string;
+    children: ReactNode;
+}
+/** Outer column of the upload surface: drop area, source picker or a single source. */
+export declare function UploadFrame({ isCompact, isDimmed, className, children }: UploadFrameProps): import("react").JSX.Element;
+export interface UploadDropAreaProps {
+    isActive: boolean;
+    isDisabled: boolean;
+    isProcessing: boolean;
+    processingMessage: string;
+    isCompact?: boolean;
+    title: string;
+    subtitle?: string;
+    onDrag: DragEventHandler<HTMLDivElement>;
+    onDrop: DragEventHandler<HTMLDivElement>;
+    /** Receives clicks on the area itself (the host filters out clicks on child buttons). */
+    onClick: MouseEventHandler<HTMLDivElement>;
+    /** Browse actions shown inside the box (compact mode). */
+    actions?: ReactNode;
+    testId?: string;
+}
+/** The drag-and-drop box: icon, title, subtitle, a processing overlay and optional actions. */
+export declare function UploadDropArea({ isActive, isDisabled, isProcessing, processingMessage, isCompact, title, subtitle, onDrag, onDrop, onClick, actions, testId, }: UploadDropAreaProps): import("react").JSX.Element;
+export interface UploadBrowseButtonsProps {
+    onFiles: MouseEventHandler<HTMLButtonElement>;
+    onFolder: MouseEventHandler<HTMLButtonElement>;
+    isDisabled?: boolean;
+    /** `inline` sits inside the drop box; `grid` is two full-width columns below it. */
+    layout?: 'inline' | 'grid';
+    labels?: Partial<UploadSourcesLabels>;
+}
+/** "Choose files" + "Choose a folder" buttons (ids `upload-files-button`, `upload-folder-button`). */
+export declare function UploadBrowseButtons({ onFiles, onFolder, isDisabled, layout, labels, }: UploadBrowseButtonsProps): import("react").JSX.Element;
+export interface UploadSourceOption {
+    key: string;
+    label: string;
+    description: string;
+    icon: ReactNode;
+    onClick?: () => void;
+    /** Wraps the option's button (e.g. in a dialog trigger that owns its click). */
+    wrap?: (button: ReactNode) => ReactNode;
+}
+export interface UploadSourcePickerProps {
+    options: UploadSourceOption[];
+    isDisabled?: boolean;
+}
+/** Chooser of where files come from (ids `upload-source-picker`, `upload-source-pick-<key>`). */
+export declare function UploadSourcePicker({ options, isDisabled }: UploadSourcePickerProps): import("react").JSX.Element;
+export interface UploadUrlButtonProps {
+    isCompact?: boolean;
+    isDisabled?: boolean;
+    label?: string;
+    /** Set when the button is not wrapped in a trigger that owns its click. */
+    onClick?: () => void;
+}
+/** "Add from URL" button (id `upload-url-button`); wrap it in the URL dialog's trigger. */
+export declare function UploadUrlButton({ isCompact, isDisabled, label, onClick, }: UploadUrlButtonProps): import("react").JSX.Element;
+export interface UploadSourceSectionProps {
+    testId?: string;
+    className?: string;
+    /** Swallow clicks so a surrounding clickable area does not also fire. */
+    isIsolated?: boolean;
+    children: ReactNode;
+}
+/** One focused source (computer / internet / email) of the scoped upload view. */
+export declare function UploadSourceSection({ testId, className, isIsolated, children, }: UploadSourceSectionProps): import("react").JSX.Element;

package/dist/files/VersionTimeline.d.ts

@@ -0,0 +1,60 @@
+/** Every fixed string of the timeline. Pass a partial `labels` to translate or reword. */
+export interface VersionTimelineLabels {
+    emptyLive: string;
+    emptyDocument: string;
+    untitled: string;
+    latest: string;
+    viewing: string;
+    current: string;
+    version: (n: number) => string;
+    branchedFrom: (n: number) => string;
+    open: string;
+    compare: string;
+}
+export declare const DEFAULT_VERSION_TIMELINE_LABELS: VersionTimelineLabels;
+export interface VersionTimelineTestIds {
+    root: string;
+    empty: string;
+    currentBadge: string;
+    /** Replaces the whole `version-row-<id>` id. */
+    row: (id: string) => string;
+    branch: (id: string) => string;
+    open: (id: string) => string;
+    compare: (id: string) => string;
+}
+export interface VersionEntry {
+    id: string;
+    /** File name as stored (live artifacts have their extension stripped for display). */
+    name: string;
+    /** ISO string; formatted with `formatDate`. */
+    createdAt: string;
+    /** The version this one was saved from (a branch when it is not the row above). */
+    parentId?: string | null;
+}
+export interface VersionTimelineProps {
+    /** Versions in creation order (oldest first). */
+    versions: VersionEntry[];
+    /** The version currently open. */
+    currentId: string;
+    /**
+     * A live (html/react) artifact: plain-language labels for non-developers, no file extension,
+     * and no Compare (a text diff of source code means nothing to them).
+     */
+    live?: boolean;
+    formatDate: (iso: string) => string;
+    onOpen: (id: string) => void;
+    /** Omit to hide Compare (also hidden for `live`). */
+    onCompare?: (id: string) => void;
+    className?: string;
+    labels?: Partial<VersionTimelineLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<VersionTimelineTestIds>;
+}
+/**
+ * Clickable timeline of an immutable version chain: open any version or compare it with the
+ * current one. Versions are numbered in creation order; a version saved from an OLD version is a
+ * deliberate branch and says where it came from instead of implying it follows the row above.
+ * Test ids: `version-timeline`, `version-timeline-empty`, `version-row-{id}`,
+ * `version-current-badge`, `version-branch-{id}`, `open-version-{id}`, `compare-version-{id}`.
+ */
+export declare function VersionTimeline({ versions, currentId, live, formatDate, onOpen, onCompare, className, labels, testIds, }: VersionTimelineProps): import("react").JSX.Element;

package/dist/files/ViewToggle.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode } from 'react';
+/** Names of the four document view modes. Pass a partial `labels` to translate or reword. */
+export interface DocumentViewToggleLabels {
+    gallery: string;
+    table: string;
+    review: string;
+    smartSearch: string;
+}
+export declare const DEFAULT_DOCUMENT_VIEW_TOGGLE_LABELS: DocumentViewToggleLabels;
+export interface ViewToggleOption {
+    value: string;
+    icon: ReactNode;
+    label: string;
+}
+export interface ViewToggleProps {
+    options: ViewToggleOption[];
+    value: string;
+    onChange: (value: string) => void;
+    /** Item test ids are `${testIdPrefix}-${value}-button`. */
+    testIdPrefix?: string;
+    showLabels?: boolean;
+    hideTooltips?: boolean;
+    size?: 'default' | 'sm';
+    /**
+     * Collapse labels to icons by the width of the nearest `@container` ancestor instead of the
+     * viewport. The consumer must mark that region `@container`.
+     */
+    containerCollapse?: boolean;
+    className?: string;
+}
+/** Segmented view switch: selected = accent tint, tone-only hover, 44px targets on touch. */
+export declare function ViewToggle({ options, value, onChange, testIdPrefix, showLabels, hideTooltips, size, containerCollapse, className, }: ViewToggleProps): import("react").JSX.Element;
+export type DocumentViewMode = 'grid' | 'explorer' | 'navigator' | 'search';
+export interface DocumentViewToggleProps {
+    viewMode: DocumentViewMode;
+    onChange: (mode: DocumentViewMode) => void;
+    /** Collapse the four modes into one select trigger (narrow viewports). */
+    compact?: boolean;
+    labels?: Partial<DocumentViewToggleLabels>;
+    /** Overrides the segmented items' prefix (default `documents-layout`: `<prefix>-<mode>-button`). */
+    testIdPrefix?: string;
+    /** Overrides the compact select test ids (defaults keep the current ids). */
+    compactTestIds?: Partial<{
+        select: string;
+        option: (mode: DocumentViewMode) => string;
+    }>;
+}
+/** The Documents page's Gallery / Table / Review / Smart Search switch. */
+export declare function DocumentViewToggle({ viewMode, onChange, compact, labels, testIdPrefix, compactTestIds, }: DocumentViewToggleProps): import("react").JSX.Element;

package/dist/files/ViewerChrome.d.ts

@@ -0,0 +1,155 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the viewer chrome and parts. Pass a partial `labels` to translate or reword. */
+export interface ViewerLabels {
+    shared: string;
+    edit: string;
+    cancel: string;
+    cancelEditing: string;
+    compare: string;
+    compareTitle: string;
+    saveDocument: string;
+    saveAsVersion: string;
+    noChanges: string;
+    saving: string;
+    save: string;
+    saveVersion: string;
+    useAsReference: string;
+    useAsReferenceTitle: string;
+    crop: string;
+    cropTitle: string;
+    previousPage: string;
+    nextPage: string;
+    zoomIn: string;
+    zoomOut: string;
+    zoomReset: (level: string) => string;
+    pageInput: string;
+    pageOfTitle: string;
+    pageOf: (page: number, total: number) => string;
+    compareVs: string;
+    trackChanges: string;
+    trackChangesBack: string;
+    trackChangesView: string;
+    flipComparison: string;
+    stopComparing: string;
+    previewUnavailable: string;
+    cannotPreview: (extension: string) => string;
+    downloadToOpen: string;
+    download: string;
+}
+export declare const DEFAULT_VIEWER_LABELS: ViewerLabels;
+export interface ViewerFrameTestIds {
+    root: string;
+    compareRow: string;
+    /** Replaces the whole `document-viewer-content-<id>` id. */
+    content: string;
+}
+export interface ViewerFrameProps {
+    /** The sticky top bar (tabs + title + actions). */
+    header: ReactNode;
+    /** "Comparing against..." chips, shown on their own row under the header when set. */
+    compareRow?: ReactNode;
+    /** Document id; the content area's test id is `document-viewer-content-{id}`. */
+    contentId: string;
+    children: ReactNode;
+    /** Rendered after the content area (modals owned by the viewer, e.g. crop). */
+    footer?: ReactNode;
+    frameRef?: React.Ref<HTMLDivElement>;
+    className?: string;
+    testIds?: Partial<ViewerFrameTestIds>;
+}
+/** The document viewer shell: sticky header, optional compare row, scrolling content. */
+export declare const ViewerFrame: ({ header, compareRow, contentId, children, footer, frameRef, className, testIds, }: ViewerFrameProps) => import("react").JSX.Element;
+/** Centered muted status line for loading / error states inside the viewer. */
+export declare function ViewerMessage({ children, testId }: {
+    children: ReactNode;
+    testId?: string;
+}): import("react").JSX.Element;
+export interface ViewerTitleProps {
+    title: string;
+    /** Shows the small shared marker. */
+    shared?: boolean;
+    /** e.g. "v3". */
+    versionLabel?: string | null;
+    /** Let the pill shrink (live artifacts share the row with more controls). */
+    shrink?: boolean;
+    labels?: Partial<ViewerLabels>;
+    /** Overrides the shared-marker test id (default `document-title-shared-indicator`). */
+    sharedTestId?: string;
+}
+/** Read-only document name pill with the shared marker and version label. */
+export declare function ViewerTitle({ title, shared, versionLabel, shrink, labels, sharedTestId, }: ViewerTitleProps): import("react").JSX.Element;
+export interface ViewerEditActionsProps {
+    isEditing: boolean;
+    isDraft: boolean;
+    /** Narrow panel: icon-only Edit/Compare. Save keeps its label. */
+    compact: boolean;
+    hasChanges: boolean;
+    isSaving: boolean;
+    /** Offer "Compare against the previous version". */
+    canCompare: boolean;
+    onStartEdit: () => void;
+    onCancel: () => void;
+    onCompare: () => void;
+    onSave: () => void;
+    labels?: Partial<ViewerLabels>;
+    testIds?: Partial<ViewerEditActionsTestIds>;
+}
+export interface ViewerEditActionsTestIds {
+    edit: string;
+    cancel: string;
+    compare: string;
+    save: string;
+    unsavedDot: string;
+}
+/**
+ * Edit / Cancel / Compare / Save. Save is the ONE filled button and only once there is something
+ * to save; a dot marks unsaved changes as a second glanceable signal.
+ */
+export declare function ViewerEditActions({ isEditing, isDraft, compact, hasChanges, isSaving, canCompare, onStartEdit, onCancel, onCompare, onSave, labels, testIds, }: ViewerEditActionsProps): import("react").JSX.Element;
+export interface ViewerImageActionsProps {
+    compact: boolean;
+    onUseAsReference: () => void;
+    onCrop: () => void;
+    labels?: Partial<ViewerLabels>;
+    testIds?: Partial<{
+        useAsReference: string;
+        crop: string;
+    }>;
+}
+/** Image-only actions: feed it into a new generation, or crop it into a new version. */
+export declare function ViewerImageActions({ compact, onUseAsReference, onCrop, labels, testIds, }: ViewerImageActionsProps): import("react").JSX.Element;
+export interface PdfPageNavProps {
+    canPrev: boolean;
+    canNext: boolean;
+    onPrev: () => void;
+    onNext: () => void;
+    /** The "3 / 12" counter between the arrows (the host owns its editing behaviour). */
+    counter: ReactNode;
+    labels?: Partial<ViewerLabels>;
+    testIds?: Partial<{
+        overlay: string;
+        prev: string;
+        next: string;
+    }>;
+}
+/** Floating prev / counter / next control over a rendered PDF. */
+export declare function PdfPageNav({ canPrev, canNext, onPrev, onNext, counter, labels, testIds, }: PdfPageNavProps): import("react").JSX.Element;
+export interface ViewerZoomControlProps {
+    /** Multiplier of the fit-width size (1 = fit width). */
+    zoom: number;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    /** Back to fit width (the level readout is the button). */
+    onReset: () => void;
+    labels?: Partial<ViewerLabels>;
+    testIds?: Partial<{
+        overlay: string;
+        in: string;
+        out: string;
+        level: string;
+    }>;
+}
+/** Floating zoom pill sitting just above the page control: "- 150% +". */
+export declare function ViewerZoomControl({ zoom, canZoomIn, canZoomOut, onZoomIn, onZoomOut, onReset, labels, testIds, }: ViewerZoomControlProps): import("react").JSX.Element;

package/dist/files/ViewerLayout.d.ts

@@ -0,0 +1,32 @@
+import type { ReactNode } from 'react';
+/** Left side of the viewer header: tabs, title and status; shrinks and clips. */
+export declare function ViewerHeaderStart({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Right side of the viewer header: the actions; never shrinks. */
+export declare function ViewerHeaderEnd({ isCompact, children, }: {
+    isCompact?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Muted inline status next to the title ("streaming...", "Draft — not saved"). */
+export declare function ViewerStatusNote({ pulse, testId, children, }: {
+    /** Animate while something is being produced. */
+    pulse?: boolean;
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/**
+ * A pane of the viewer body. `hidden` keeps it mounted but out of sight (media keeps playing
+ * while the transcript is read); `scroll` makes the pane scroll itself.
+ */
+export declare function ViewerPane({ hidden, scroll, testId, children, }: {
+    hidden?: boolean;
+    scroll?: boolean;
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** Padding around rendered (read-only) markdown. */
+export declare function ViewerRenderedPane({ testId, children }: {
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/files/ViewerParts.d.ts

@@ -0,0 +1,62 @@
+import type { ReactNode } from 'react';
+import { type ViewerLabels } from './ViewerChrome';
+export interface ViewerTab {
+    id: string;
+    icon: ReactNode;
+    /** Tooltip and accessible name. */
+    tooltip: string;
+    /** Visible text next to the icon, for tabs whose icon alone is not self-explanatory. */
+    label?: string;
+    /** Overrides the tab test id (default `<id>-tab`). */
+    testId?: string;
+}
+export interface ViewerTabBarProps {
+    tabs: ViewerTab[];
+    activeId: string;
+    onChange: (id: string) => void;
+    className?: string;
+}
+/** Underline tab strip for the viewer's formats (PDF, DOCX, Source, Versions, HTML...). */
+export declare function ViewerTabBar({ tabs, activeId, onChange, className }: ViewerTabBarProps): import("react").JSX.Element;
+export interface ViewerPageCounterProps {
+    page: number;
+    total: number;
+    /** Called with a valid 1..total page typed into the counter. */
+    onGoTo: (page: number) => void;
+    labels?: Partial<ViewerLabels>;
+}
+/** "3 / 12": click the number to type a page; Enter or blur commits, Escape cancels. */
+export declare function ViewerPageCounter({ page, total, onGoTo, labels }: ViewerPageCounterProps): import("react").JSX.Element | null;
+export interface ViewerCompareBarProps {
+    /** The compared-against document pill (the host renders its entity). */
+    compareTarget: ReactNode;
+    versionLabel?: string | null;
+    /** Artifacts toggle "Track changes"; plain documents get a flip-direction arrow instead. */
+    mode: 'track-changes' | 'flip';
+    showTrackChanges: boolean;
+    onToggleTrackChanges: () => void;
+    onFlip: () => void;
+    onStop: () => void;
+    labels?: Partial<ViewerLabels>;
+    /** Overrides the track-changes toggle test id (default `track-changes-toggle`). */
+    trackChangesTestId?: string;
+}
+/**
+ * "Compare vs. [doc]" row contents: always an explicit text label (an icon-only pill was unclear),
+ * with Track changes (artifacts) or Flip (plain documents), and Stop comparing.
+ */
+export declare function ViewerCompareBar({ compareTarget, versionLabel, mode, showTrackChanges, onToggleTrackChanges, onFlip, onStop, labels, trackChangesTestId, }: ViewerCompareBarProps): import("react").JSX.Element;
+/** A format that cannot be previewed in the browser: offer the original instead. */
+export declare function ViewerPreviewUnavailable({ extension, onDownload, labels, }: {
+    extension: string;
+    onDownload: () => void;
+    labels?: Partial<ViewerLabels>;
+}): import("react").JSX.Element;
+/** The file failed to load: say so and offer the download instead. */
+export declare function ViewerLoadError({ message, onDownload, labels, testId, }: {
+    message: string;
+    onDownload: () => void;
+    labels?: Partial<ViewerLabels>;
+    /** Overrides the root test id (default `pdf-load-error`). */
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/files/bulk/BulkActionsBar.d.ts

@@ -0,0 +1,76 @@
+import { type SelectionBarProps } from '../SelectionBar';
+import { type ShareControlLabels, type ShareState } from '../../collaboration/sharing/ShareControl';
+/** Every fixed string of the bulk bar. Pass a partial `labels` to translate or reword. */
+export interface BulkActionsLabels {
+    chat: string;
+    chatTooltip: string;
+    annotate: string;
+    annotateTooltip: string;
+    label: string;
+    labelTooltip: string;
+    share: string;
+    makePrivate: string;
+    more: string;
+    folder: string;
+    export: string;
+    reprocess: string;
+    removeOffline: string;
+    useOffline: string;
+    delete: string;
+}
+export declare const DEFAULT_BULK_ACTIONS_LABELS: BulkActionsLabels;
+export interface BulkActionsTestIds {
+    chat: string;
+    annotate: string;
+    label: string;
+    more: string;
+    moveFolder: string;
+    share: string;
+    export: string;
+    reprocess: string;
+    offline: string;
+    delete: string;
+}
+export interface BulkActionsBarProps {
+    /** Number of selected documents; the bar is hidden at 0. */
+    count: number;
+    onClear: () => void;
+    onReview?: () => void;
+    /** Members get annotate / label / share / folder / export / reprocess / delete. */
+    isMember: boolean;
+    /** Online-only actions (export, reprocess, enabling offline) are disabled while offline. */
+    isOnline: boolean;
+    onChat: () => void;
+    onAnnotate: () => void;
+    onLabel: () => void;
+    onMoveToFolder: () => void;
+    onExport: () => void;
+    onReprocess: () => void;
+    /** Label of the reprocess item (the app adds the "(max N)" cap hint). */
+    reprocessLabel?: string;
+    onToggleOffline: () => void;
+    /** All selected docs are already available offline: the item removes them instead. */
+    isAllOffline: boolean;
+    isOfflinePending?: boolean;
+    onDelete: () => void;
+    /** Visibility of the selection (all shared, none shared, or a mix). */
+    shareState: ShareState;
+    /** `true` = share with the workspace, `false` = make private. */
+    onToggleShare: (shouldShare: boolean) => void;
+    /** Tooltip of the share button (what a click does). */
+    shareTooltip?: string;
+    /** Labels of the share control (Share / Shared / Private). */
+    shareLabels?: Partial<ShareControlLabels>;
+    className?: string;
+    labels?: Partial<BulkActionsLabels>;
+    /** Overrides for the control test ids (defaults keep the current ids). */
+    testIds?: Partial<BulkActionsTestIds>;
+    /** Labels / test ids of the underlying selection bar (count, clear, review). */
+    selectionBar?: Pick<SelectionBarProps, 'labels' | 'testIds'>;
+}
+/**
+ * Bulk actions for selected documents, composed on the `SelectionBar`. Primary actions stay
+ * inline (Chat, AI Annotate, Label, Shared); the rest fold into a "More" menu to keep the bar
+ * on one row. Data-free: every action is a callback, the visibility toggle is a slot.
+ */
+export declare function BulkActionsBar({ count, onClear, onReview, isMember, isOnline, onChat, onAnnotate, onLabel, onMoveToFolder, onExport, onReprocess, reprocessLabel, onToggleOffline, isAllOffline, isOfflinePending, onDelete, shareState, onToggleShare, shareTooltip, shareLabels, className, labels, testIds, selectionBar, }: BulkActionsBarProps): import("react").JSX.Element;

package/dist/files/bulk/FolderFilterButton.d.ts

@@ -0,0 +1,35 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the folder filter. Pass a partial `labels` to translate or reword. */
+export interface FolderFilterLabels {
+    all: string;
+    newFolder: string;
+}
+export declare const DEFAULT_FOLDER_FILTER_LABELS: FolderFilterLabels;
+export interface FolderFilterButtonProps {
+    /** Text of the active folder ("All", "None", or the display path). */
+    label: string;
+    /** Leading glyph for connector folders; falls back to a folder icon. */
+    icon?: ReactNode;
+    /** A folder filter is active: the trigger takes the selection tint. */
+    isActive: boolean;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** Total documents, shown on the "All" row. */
+    allCount: number;
+    onSelectAll: () => void;
+    /** When set, the popover offers a "New folder" action. */
+    onNewFolder?: () => void;
+    /** Slot: the folder tree picker. */
+    children: ReactNode;
+    className?: string;
+    labels?: Partial<FolderFilterLabels>;
+    /** Test id of the trigger button (none by default). */
+    testId?: string;
+    /** Overrides the "New folder" test id (default `explorer-new-folder`). */
+    newFolderTestId?: string;
+}
+/**
+ * The folder filter control: a ghost button naming the active folder that opens a popover with
+ * an "All" row, the folder tree (slot) and an optional "New folder" action.
+ */
+export declare function FolderFilterButton({ label, icon, isActive, open, onOpenChange, allCount, onSelectAll, onNewFolder, children, className, labels, testId, newFolderTestId, }: FolderFilterButtonProps): import("react").JSX.Element;

package/dist/files/bulk/index.d.ts

@@ -0,0 +1,2 @@
+export { BulkActionsBar, DEFAULT_BULK_ACTIONS_LABELS, type BulkActionsBarProps, type BulkActionsLabels, type BulkActionsTestIds, } from './BulkActionsBar';
+export { FolderFilterButton, DEFAULT_FOLDER_FILTER_LABELS, type FolderFilterButtonProps, type FolderFilterLabels, } from './FolderFilterButton';

package/dist/files/cells/DocumentNameCell.d.ts

@@ -0,0 +1,31 @@
+import type { ReactNode } from 'react';
+export interface DocumentRowMenuProps {
+    /** Whether the user may rename / move / delete this document. */
+    canEdit: boolean;
+    onOpen: () => void;
+    onReview: () => void;
+    onDocumentChat: () => void;
+    onRename: () => void;
+    onDownload: () => void;
+    onMove: () => void;
+    onDelete: () => void;
+    testId?: string;
+}
+/** The row-actions kebab of the grid's document cell (Open, Review, Chat, Rename, ...). */
+export declare function DocumentRowMenu({ canEdit, onOpen, onReview, onDocumentChat, onRename, onDownload, onMove, onDelete, testId, }: DocumentRowMenuProps): import("react").JSX.Element;
+export interface DocumentNameCellFrameProps {
+    /** Test id on the wrapper, e.g. `open-document-viewer-button-<id>`. */
+    testId?: string;
+    /** The row's document is open in the viewer: marks the cell so the host's row style can react. */
+    isViewing?: boolean;
+    /** Phone-only second line (date and folder) under the title. */
+    subtitle?: string;
+    /** Slot: the document pill (entity chip with `actions` = a DocumentRowMenu). */
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Layout of the grid's unified "document" cell: the pill plus, on phones where the table
+ * collapses to Title + Status, a muted second line.
+ */
+export declare function DocumentNameCellFrame({ testId, isViewing, subtitle, children, className, }: DocumentNameCellFrameProps): import("react").JSX.Element;

package/dist/files/cells/FolderCell.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+export interface FolderCellProps {
+    /** Stored folder path; empty/null renders an em dash. */
+    folder: string | null | undefined;
+    /** Breadcrumb segments, already formatted for display (provider roots shortened). */
+    segments: string[];
+    /** Leading glyph for connector folders (brand mark); falls back to a folder icon. */
+    icon?: ReactNode;
+    /** Editable cells open `picker` in a popover on click. */
+    isEditable: boolean;
+    /** Popover body (the searchable folder list); only rendered for editable cells. */
+    picker?: ReactNode;
+    className?: string;
+}
+/** Breadcrumb "a / b / c" where all but the last segment are muted. */
+export declare function FolderBreadcrumb({ segments, size, }: {
+    segments: string[];
+    /** Text size of the segments: `xs` in grid cells, `sm` in form fields. */
+    size?: 'xs' | 'sm';
+}): import("react").JSX.Element;
+/**
+ * Grid cell for a document's folder. Uses the native `title` attribute instead of a Tooltip:
+ * every visible row renders one, so Radix tooltip instances would sit in the scroll hot path.
+ */
+export declare function FolderCell({ folder, segments, icon, isEditable, picker, className, }: FolderCellProps): import("react").JSX.Element;

package/dist/files/cells/HoverIconCell.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from 'react';
+export type CellHoverIconKind = 'pencil' | 'plus' | 'blocked';
+/**
+ * Edit hint of a grid cell. It appears on pointer hover, on keyboard focus anywhere inside the
+ * cell and always on touch devices (coarse pointer), where there is no hover to reveal it.
+ * Place it inside an element carrying the `group` class.
+ */
+export declare function CellHoverIcon({ kind, className, }: {
+    kind?: CellHoverIconKind;
+    className?: string;
+}): import("react").JSX.Element;
+export interface HoverIconCellProps {
+    content: ReactNode;
+    /** Non-members get a "blocked" hint instead of the edit hint. */
+    isEditable: boolean;
+    showIcon?: boolean;
+    icon?: Exclude<CellHoverIconKind, 'blocked'>;
+    className?: string;
+}
+/** A cell's content with the edit hint after it (pure CSS reveal: no re-render on mouse move). */
+export declare const HoverIconCell: import("react").NamedExoticComponent<HoverIconCellProps>;