@arbidocs/blocks 0.3.184 → 0.4.0

package/dist/files/DocumentGrid.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentType, ReactNode } from 'react';
+import { type GridViewProps } from './GridView';
+import { type DocumentGridLayout, type DocumentGridPresets } from './documentGridLayout';
+export interface DocumentGridProps<T> extends Omit<GridViewProps<T>, 'gridId' | 'initialVisibleColumns' | 'rowHeight' | 'height' | 'persistState'> {
+    /** Table, phone list or modal: each keeps its own saved state, default columns and sizing. */
+    layout: DocumentGridLayout;
+    /** Saved-state ids, default columns and row heights per layout (ids and `colId`s stay with the host). */
+    presets: DocumentGridPresets;
+    /**
+     * The grid implementation to render. Defaults to the core `GridView`; a host passes its own
+     * wrapper to add persistence of column state (the core has no store).
+     */
+    GridComponent?: ComponentType<GridViewProps<T>>;
+    /**
+     * Shown instead of the grid when the workspace has no documents at all (first-run upload
+     * prompt). The host decides when via `showEmptyWorkspace`.
+     */
+    emptyWorkspace?: ReactNode;
+    showEmptyWorkspace?: boolean;
+}
+/**
+ * The documents table: a GridView preset with the saved-state id, default columns and sizing
+ * for the current layout, remounted when the layout flips between table and phone list so state
+ * from one never leaks into the other. The host passes rows, column defs (explicit `colId`s) and
+ * handlers.
+ */
+export declare function DocumentGrid<T>({ layout, presets, GridComponent, emptyWorkspace, showEmptyWorkspace, testId, className, ...grid }: DocumentGridProps<T>): import("react").JSX.Element;

package/dist/files/Explorer.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentProps } from 'react';
+export interface ExplorerLoadingTilesProps extends ComponentProps<'div'> {
+    count?: number;
+    /** Accessible name (default "Loading files"). */
+    label?: string;
+    /** Overrides the root test id (default `explorer-loading-skeleton`). */
+    testId?: string;
+}
+/** Skeleton tile grid shown while the first page loads: the gallery reads as "filling in". */
+export declare function ExplorerLoadingTiles({ count, label, testId, className, ...rest }: ExplorerLoadingTilesProps): import("react").JSX.Element;

package/dist/files/ExplorerSurface.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentProps, type ReactNode } from 'react';
+/** Chrome around the explorer's tile grid: frame, scroller, empty state, marquee, drop overlay. */
+export declare function ExplorerFrame({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+/** Positioning context of the scroller: the marquee and the drop overlay sit over it. */
+export declare function ExplorerStage({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+/**
+ * The scrolling tile area. `scrollbar-gutter: stable` reserves the scrollbar's space whether or
+ * not it shows, so the measured width never flips when the vertical scrollbar toggles (narrow
+ * split-screen widths would otherwise thrash column count, tile height, scrollbar, width).
+ */
+export declare const ExplorerScroller: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export interface ExplorerEmptyProps {
+    title: string;
+    description: string;
+}
+/** Nothing to show in this folder / search. */
+export declare function ExplorerEmpty({ title, description }: ExplorerEmptyProps): import("react").JSX.Element;
+/**
+ * Marquee (rubber-band) rectangle. Always mounted and positioned by mutating its style directly
+ * during a drag, so selecting does not re-render the grid.
+ */
+export declare const ExplorerMarquee: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+/** Shown over the grid while files are dragged in from outside. */
+export declare function ExplorerDropOverlay({ label }: {
+    label: string;
+}): import("react").JSX.Element;
+export interface ExplorerDragPreviewProps {
+    icon: ReactNode;
+    title: string;
+    /** Number of documents dragged; shown as a badge above 1. */
+    count: number;
+}
+/** Floating preview under the cursor while dragging documents. */
+export declare function ExplorerDragPreview({ icon, title, count }: ExplorerDragPreviewProps): import("react").JSX.Element;

package/dist/files/ExplorerTile.d.ts

@@ -0,0 +1,142 @@
+import type { HTMLAttributes, MouseEvent, ReactNode, Ref } from 'react';
+import type { LucideIcon } from 'lucide-react';
+/** Every fixed string of the explorer tiles. Pass a partial `labels` to translate or reword. */
+export interface ExplorerLabels {
+    moreActions: string;
+    name: string;
+    select: string;
+    deselect: string;
+    empty: string;
+    itemCount: (count: number) => string;
+    processing: (count: number) => string;
+    aiSummary: string;
+    noSummary: string;
+    lastModifiedBy: string;
+    shared: string;
+    private: string;
+}
+export declare const DEFAULT_EXPLORER_LABELS: ExplorerLabels;
+export interface ExplorerFileTestIds {
+    root: string;
+    menu: string;
+    renameInput: string;
+}
+export interface ExplorerFolderTestIds {
+    root: string;
+    menu: string;
+    renameInput: string;
+    /** Replaces the whole `explorer-folder-processing-<path>` id. */
+    processing: string;
+}
+export type ExplorerDensity = 'grid' | 'list';
+export interface ExplorerMenuItem {
+    id: string;
+    label: string;
+    icon: LucideIcon;
+    onSelect: () => void;
+    /** Red styling, for Delete. */
+    destructive?: boolean;
+    /** Draw a separator above this item. */
+    separatorBefore?: boolean;
+    /** A nested menu: the item opens it instead of acting (`onSelect` is then ignored). */
+    submenu?: ExplorerMenuItem[];
+    testId?: string;
+}
+export interface ExplorerFileTileProps {
+    /** Document id (`data-doc-id`). */
+    id: string;
+    /** Rename seed: the display title. */
+    title: string;
+    density: ExplorerDensity;
+    selected: boolean;
+    /** Part of an in-flight drag: dimmed. */
+    dragging?: boolean;
+    renaming?: boolean;
+    /** First-page thumbnail (data URI/URL). Without one the file-type icon shows. */
+    thumbnailUrl?: string;
+    /** Renders the file-type glyph at a pixel size. */
+    renderFileIcon: (size: number) => ReactNode;
+    /** In-flight processing: shows a centred progress overlay with this label. */
+    progress?: {
+        label: string;
+        queued: boolean;
+    };
+    /** Terminal status marker (bottom-right), usually a `StatusPill`. */
+    statusMarker?: ReactNode;
+    /** "Available offline" marker (bottom-left). */
+    offlineMarker?: ReactNode;
+    /** The canonical entity pill at the bottom (click opens). */
+    entity: ReactNode;
+    /** Hover card content. Omit to disable the tooltip (renaming, or while dragging). */
+    tooltip?: ReactNode;
+    menuItems: ExplorerMenuItem[];
+    /** Drag-and-drop hook-up: ref + listener/aria props from the host's DnD library. */
+    rootRef?: Ref<HTMLDivElement>;
+    rootProps?: HTMLAttributes<HTMLDivElement>;
+    /** Plain click / double click / menu "Open". With `href`, a plain click still calls this. */
+    onOpen: () => void;
+    /** Route of the document: the tile gets a real link (modified clicks go to the browser). */
+    href?: string;
+    labels?: Partial<ExplorerLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<ExplorerFileTestIds>;
+    /** Modifier (shift/meta/ctrl) click: range / toggle selection. */
+    onSelect: (e: MouseEvent) => void;
+    onToggle: (e: MouseEvent) => void;
+    onCommitRename: (name: string) => void;
+    onCancelRename: () => void;
+}
+/** One document tile: thumbnail (or icon) filling the tile with checkbox, menu, status and pill. */
+export declare function ExplorerFileTile({ id, title, density, selected, dragging, renaming, thumbnailUrl, renderFileIcon, progress, statusMarker, offlineMarker, entity, tooltip, menuItems, rootRef, rootProps, onOpen, href, labels, testIds, onSelect, onToggle, onCommitRename, onCancelRename, }: ExplorerFileTileProps): import("react").JSX.Element;
+export interface ExplorerFolderTileProps {
+    /** Stored folder name (rename seed, native tooltip). */
+    name: string;
+    /** Label shown on the tile; `''`/null renders no label (provider roots shorten to nothing). */
+    displayName: string | null;
+    /** Folder path segments (ids and `data-folder-path`). */
+    path: string[];
+    /** Number of items beneath this folder; 0 renders it faded as "Empty". */
+    count: number;
+    density: ExplorerDensity;
+    editing?: boolean;
+    /** Every document beneath is selected. */
+    selected?: boolean;
+    /** Some (not all) documents beneath are selected. */
+    partiallySelected?: boolean;
+    processingCount?: number;
+    /** A dragged item is over this folder. */
+    isOver?: boolean;
+    /** Replace the folder glyph (e.g. a provider's brand mark). */
+    icon?: ReactNode;
+    menuItems?: ExplorerMenuItem[];
+    rootRef?: Ref<HTMLDivElement>;
+    rootProps?: HTMLAttributes<HTMLDivElement>;
+    onOpen: () => void;
+    /** Route of the folder: the tile gets a real link (modified clicks go to the browser). */
+    href?: string;
+    labels?: Partial<ExplorerLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<ExplorerFolderTestIds>;
+    onToggleSelect?: (e: MouseEvent) => void;
+    onCommitName?: (name: string) => void;
+    onCancelName?: () => void;
+}
+/** One folder tile: glyph, name, item count, optional processing count and actions menu. */
+export declare function ExplorerFolderTile({ name, displayName, path, count, density, editing, selected, partiallySelected, processingCount, isOver, icon, menuItems, rootRef, rootProps, onOpen, href, labels, testIds, onToggleSelect, onCommitName, onCancelName, }: ExplorerFolderTileProps): import("react").JSX.Element;
+export interface ExplorerFileTooltipProps {
+    title: string;
+    /** AI summary; a placeholder is shown when empty. */
+    summary?: string | null;
+    /** Pre-formatted "last modified" date; omit to hide the meta rows. */
+    modifiedLabel?: string | null;
+    /** Small avatar of whoever last modified it. */
+    modifiedByAvatar?: ReactNode;
+    shared: boolean;
+    /** Glyph for the shared/private state. */
+    visibilityIcon?: ReactNode;
+    labels: string[];
+    /** Fixed strings of the card (not the document labels above). */
+    uiLabels?: Partial<ExplorerLabels>;
+}
+/** The explorer hover card: leads with the AI summary, then who/when and the labels. */
+export declare function ExplorerFileTooltip({ title, summary, modifiedLabel, modifiedByAvatar, shared, visibilityIcon, labels, uiLabels, }: ExplorerFileTooltipProps): import("react").JSX.Element;

package/dist/files/ExportParts.d.ts

@@ -0,0 +1,114 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the export parts. Pass a partial `labels` to translate or reword. */
+export interface ExportLabels {
+    export: string;
+    selected: (count: number) => string;
+    exportMethod: string;
+    downloadToComputer: string;
+    downloadDescription: string;
+    exportColumns: string;
+    columnsVisible: string;
+    columnsAll: string;
+    columnsFiles: string;
+    columnsHelp: string;
+    exportToWorkspace: string;
+    exportToWorkspaceDescription: string;
+    selectTargetWorkspace: string;
+    noOtherWorkspaces: string;
+    member: string;
+    members: string;
+    result: string;
+    noItemDetail: string;
+    done: string;
+    cancel: string;
+}
+export declare const DEFAULT_EXPORT_LABELS: ExportLabels;
+export interface ExportModalTitleProps {
+    /** Workspace crumb (icon + name); omit when there is no current workspace. */
+    workspace?: {
+        icon: ReactNode;
+        name: string;
+    };
+    /** Icon and plural noun of what is exported. */
+    entityIcon: ReactNode;
+    entityPlural: string;
+    selectedCount: number;
+    labels?: Partial<ExportLabels>;
+}
+/** `Workspace / Chats / Export  [3 selected]` for the Export dialog title. */
+export declare function ExportModalTitle({ workspace, entityIcon, entityPlural, selectedCount, labels, }: ExportModalTitleProps): import("react").JSX.Element;
+export type ExportMode = 'workspace' | 'download';
+export type ExportColumnsMode = 'visible' | 'all' | 'files';
+export interface ExportMethodChooserProps {
+    mode: ExportMode;
+    onModeChange: (mode: ExportMode) => void;
+    columnsMode: ExportColumnsMode;
+    onColumnsModeChange: (mode: ExportColumnsMode) => void;
+    labels?: Partial<ExportLabels>;
+    /** Overrides the columns select test id (default `export-columns-selector`). */
+    columnsTestId?: string;
+}
+/** "Download to computer" vs "Export to another workspace", with the CSV columns picker. */
+export declare function ExportMethodChooser({ mode, onModeChange, columnsMode, onColumnsModeChange, labels, columnsTestId, }: ExportMethodChooserProps): import("react").JSX.Element;
+export interface ExportWorkspaceOption {
+    id: string;
+    name: string;
+    description?: string | null;
+    memberCount: number;
+    /** Workspace icon (32px). */
+    icon: ReactNode;
+    /** Member avatars (the host decides which and how many). */
+    members?: ReactNode;
+}
+export interface ExportWorkspacePickerProps {
+    workspaces: ExportWorkspaceOption[];
+    selectedId: string | null;
+    onSelect: (id: string) => void;
+    labels?: Partial<ExportLabels>;
+    /** Replaces the whole `export-workspace-<id>` id. */
+    testId?: (id: string) => string;
+}
+/** Pick the workspace to export into. */
+export declare function ExportWorkspacePicker({ workspaces, selectedId, onSelect, labels, testId, }: ExportWorkspacePickerProps): import("react").JSX.Element;
+export interface ExportResultRowView {
+    id: string;
+    tone: 'success' | 'warning' | 'error';
+    name: string;
+    /** User-facing kind, e.g. "Document". */
+    kind: string;
+    detail?: string;
+}
+export interface ExportResultsReportProps {
+    /** One-line outcome, e.g. "Exported 3 documents. 1 failed." */
+    summary: string;
+    /** Failures first, then warnings, then clean rows (the host orders them). */
+    rows: ExportResultRowView[];
+    onDone: () => void;
+    labels?: Partial<ExportLabels>;
+    testIds?: Partial<ExportResultsTestIds>;
+}
+export interface ExportResultsTestIds {
+    root: string;
+    summary: string;
+    done: string;
+    /** Replaces the whole `export-result-<id>` id. */
+    row: (id: string) => string;
+}
+/**
+ * Per-item outcome list. A batch can come back part-succeeded, with warnings that are not
+ * failures, so every item that did not cleanly succeed is named with its reason.
+ */
+export declare function ExportResultsReport({ summary, rows, onDone, labels, testIds, }: ExportResultsReportProps): import("react").JSX.Element;
+export interface ExportFooterProps {
+    onCancel?: () => void;
+    onSubmit: () => void;
+    submitLabel: string;
+    submitDisabled: boolean;
+    labels?: Partial<ExportLabels>;
+    testIds?: Partial<{
+        cancel: string;
+        submit: string;
+    }>;
+}
+/** Sticky Cancel + the ONE primary Export button. */
+export declare function ExportFooter({ onCancel, onSubmit, submitLabel, submitDisabled, labels, testIds, }: ExportFooterProps): import("react").JSX.Element;

package/dist/files/FieldParts.d.ts

@@ -0,0 +1,64 @@
+import { type ReactNode } from 'react';
+import { type LabelMultiSelectLabels, type LabelOption } from './cells/LabelMultiSelect';
+export interface FieldValueProps {
+    tone?: 'default' | 'strong' | 'muted';
+    isMono?: boolean;
+    isTruncated?: boolean;
+    children: ReactNode;
+}
+/** A read-only value of a field. */
+export declare function FieldValue({ tone, isMono, isTruncated, children }: FieldValueProps): import("react").JSX.Element;
+export interface FieldFolderSelectProps {
+    /** Current folder path, if any. */
+    folder: string | null | undefined;
+    /** Searchable folder list (host-bound `FolderCommandList`). */
+    picker: ReactNode;
+}
+/** Folder field: a trigger showing the breadcrumb, opening the folder picker in a popover. */
+export declare function FieldFolderSelect({ folder, picker }: FieldFolderSelectProps): import("react").JSX.Element;
+/** Read-only folder. */
+export declare function FieldFolderValue({ folder }: {
+    folder: string | null | undefined;
+}): import("react").JSX.Element;
+export interface FieldLabelsSelectProps {
+    options: LabelOption[];
+    appliedIds: ReadonlySet<string>;
+    /** Labels shown as check marks in the field (defaults to the applied ones). Pass fewer to list
+     *  the selection elsewhere, e.g. in a dialog that renders it beside the field. */
+    displayedIds?: ReadonlySet<string>;
+    onToggle: (id: string) => void;
+    /** Create a label and apply it; omit to make the picker toggle-only. */
+    onCreate?: (name: string) => void;
+    emptyText?: string;
+    labels?: Partial<LabelMultiSelectLabels>;
+}
+/** Labels field: the applied labels as check marks; click to open the label picker. */
+export declare function FieldLabelsSelect({ options, appliedIds, displayedIds, onToggle, onCreate, emptyText, labels, }: FieldLabelsSelectProps): import("react").JSX.Element;
+export interface FieldNativeSelectProps {
+    value: string;
+    options: string[];
+    onChange: (value: string) => void;
+    /** Text of the empty option. */
+    emptyLabel?: string;
+    ariaLabel?: string;
+}
+/** A single-choice field (a native `select`: reliable on touch and with assistive tech). */
+export declare function FieldNativeSelect({ value, options, onChange, emptyLabel, ariaLabel, }: FieldNativeSelectProps): import("react").JSX.Element;
+export interface FieldAttributionProps {
+    /** Avatar of whoever last changed the value. */
+    avatar: ReactNode;
+    /** Formatted date of that change. */
+    date: string;
+    /** Tooltip lines ("Created ... by ...", "Updated ... by ..."). */
+    lines: string[];
+}
+/** Subtle "who changed this and when". */
+export declare function FieldAttribution({ avatar, date, lines }: FieldAttributionProps): import("react").JSX.Element;
+/**
+ * Wraps an editable value and reveals `attribution` at its top-right on hover or keyboard focus
+ * inside, and always on touch devices (there is no hover there).
+ */
+export declare function FieldWithAttribution({ attribution, children, }: {
+    attribution: ReactNode;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/files/FilesPage.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentProps } from 'react';
+export interface FilesPageProps extends ComponentProps<'div'> {
+    /** Inside a modal the page keeps its own height instead of filling the page scroll zone. */
+    isModal?: boolean;
+    /** Overrides the root test id (default `documents-page`). */
+    testId?: string;
+}
+/**
+ * Files page column. `h-full` fills the bounded page scroll zone (not 100vh), so when a tip bar
+ * shrinks the shell this column shrinks with it and the sticky selection bar stays pinned to the
+ * visible bottom.
+ */
+export declare function FilesPage({ isModal, testId, className, ...props }: FilesPageProps): import("react").JSX.Element;
+/**
+ * Sticky region on top: the title row (title, view switch, Add) and the calm filter row. 16px
+ * gutters on phones, 24px from `sm`, the same as the other pages.
+ */
+export declare function FilesPageHeader({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+/** The scrolling content area (grid, gallery, review, smart search). */
+export declare function FilesPageMain({ className, ...props }: ComponentProps<'main'>): import("react").JSX.Element;

package/dist/files/FilesToolbar.d.ts

@@ -0,0 +1,59 @@
+import type { ComponentProps, ReactNode } from 'react';
+export interface FilesToolbarProps extends Omit<ComponentProps<'div'>, 'children'> {
+    /** Leading controls: the filter field and the pickers that narrow the list. */
+    leftActions?: ReactNode;
+    /** Trailing controls (row navigator, views, density...). Always visible; nothing is hover-revealed. */
+    rightActions?: ReactNode;
+    className?: string;
+    /** Overrides the root test id (default `documents-filter-bar`). */
+    testId?: string;
+}
+/**
+ * The calm secondary row under the page title: filters on the left, view controls on the right.
+ * No border or fill: the page header already separates it. It wraps by GROUP, never mid-group:
+ * the left group (filter field + pickers) keeps one line, and when the view controls no longer
+ * fit beside it they drop together onto their own right-aligned line, so a docked tablet sidebar
+ * or a phone never orphans a single button.
+ */
+export declare function FilesToolbar({ leftActions, rightActions, className, testId, ...rest }: FilesToolbarProps): import("react").JSX.Element;
+export interface FilesSearchField {
+    value: string;
+    label: string;
+}
+/** Every fixed string of the search input. Pass a partial `labels` to translate or reword. */
+export interface FilesSearchLabels {
+    placeholder: string;
+    clearFilter: string;
+    chooseFields: string;
+}
+export declare const DEFAULT_FILES_SEARCH_LABELS: FilesSearchLabels;
+export interface FilesSearchTestIds {
+    root: string;
+    filterSlot: string;
+    input: string;
+    fieldsButton: string;
+}
+export interface FilesSearchInputProps {
+    value: string;
+    onChange: (value: string) => void;
+    /** Fields the text can match against. */
+    fields: FilesSearchField[];
+    /** Currently searched field values. */
+    selectedFields: string[];
+    onSelectedFieldsChange: (fields: string[]) => void;
+    /** Wins over `labels.placeholder`. */
+    placeholder?: string;
+    labels?: Partial<FilesSearchLabels>;
+    /** Overrides for the control test ids (defaults keep the current ids). */
+    testIds?: Partial<FilesSearchTestIds>;
+    /** Width/layout classes for the outer wrapper. */
+    className?: string;
+    /** Leading control inside the input (e.g. the filter dropdown trigger). */
+    filterSlot?: ReactNode;
+}
+/**
+ * Inline "Filter..." box. The filter slot sits INSIDE the input on the left; on the right a muted
+ * field picker chooses which fields the text matches, and a clear control shows while there is
+ * text. Both inline controls stay visible and are 32px+ on touch.
+ */
+export declare function FilesSearchInput({ value, onChange, fields, selectedFields, onSelectedFieldsChange, placeholder, labels, testIds, className, filterSlot, }: FilesSearchInputProps): import("react").JSX.Element;

package/dist/files/FolderPicker.d.ts

@@ -0,0 +1,82 @@
+import type { ReactNode } from 'react';
+/** Every fixed string of the folder pickers. Pass a partial `labels` to translate or reword. */
+export interface FolderPickerLabels {
+    none: string;
+    removeFromFolder: string;
+    searchOrCreate: string;
+    noFolders: string;
+    create: (name: string) => string;
+}
+export declare const DEFAULT_FOLDER_PICKER_LABELS: FolderPickerLabels;
+export interface FolderCommandListTestIds {
+    create: string;
+    createOption: string;
+    remove: string;
+    /** Replaces the whole `folder-picker-option-<folder>` id. */
+    option: (folder: string) => string;
+}
+export interface FolderPickerRowProps {
+    label: string;
+    /** Optional leading glyph (e.g. a connector brand mark for provider roots). */
+    icon?: ReactNode;
+    count: number;
+    depth: number;
+    isActive: boolean;
+    muted?: boolean;
+    /** Test id of the row button (none by default). */
+    testId?: string;
+    /**
+     * Draw a checkbox in the leading slot instead of the single-select tick. A list you can pick
+     * SEVERAL rows from should look like one: a lone tick reads "this is the current one", a box
+     * reads "tick the ones you want".
+     */
+    checkbox?: boolean;
+    /** Checkbox only: some descendants are selected, so show a dash, not a tick. */
+    indeterminate?: boolean;
+    onClick: () => void;
+}
+/** One folder row: indented by depth, with a count. Whole row is the target (44px on touch). */
+export declare function FolderPickerRow({ label, icon, count, depth, isActive, muted, checkbox, indeterminate, testId, onClick, }: FolderPickerRowProps): import("react").JSX.Element;
+export interface FolderTreeNode {
+    path: string;
+    label: string;
+    depth: number;
+    count: number;
+    /** Replaces the label's default look (provider roots show a brand mark). */
+    icon?: ReactNode;
+}
+export interface FolderTreeProps {
+    nodes: FolderTreeNode[];
+    unfiledCount: number;
+    /** string = folder path selected, null = Unfiled selected, undefined = nothing selected. */
+    value: string | null | undefined;
+    onChange: (folder: string | null) => void;
+    /** Show the Unfiled ("None") row even when it is empty. */
+    showUnfiledAlways?: boolean;
+    labels?: Partial<FolderPickerLabels>;
+}
+/** Folder hierarchy with an Unfiled option at the bottom. No "All" row: callers add their own. */
+export declare function FolderTree({ nodes, unfiledCount, value, onChange, showUnfiledAlways, labels, }: FolderTreeProps): import("react").JSX.Element;
+export interface FolderCommandListProps {
+    /** Existing folder paths (the host derives them from its documents). */
+    folders: string[];
+    /** Selected folder (null = unfiled, undefined = no selection). */
+    value?: string | null;
+    /** A folder was picked or a new one created. */
+    onSelect: (folder: string | null) => void;
+    /** Show the remove / move-to-root option. */
+    showRemove?: boolean;
+    /** Wins over `labels.removeFromFolder`. */
+    removeLabel?: string;
+    /** Wins over `labels.searchOrCreate`. */
+    placeholder?: string;
+    autoFocus?: boolean;
+    labels?: Partial<FolderPickerLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<FolderCommandListTestIds>;
+}
+/**
+ * Searchable folder picker: filter existing folders, create one by typing a new name, optional
+ * "Remove from folder". Shows hierarchy as breadcrumbs.
+ */
+export declare function FolderCommandList({ folders, value, onSelect, showRemove, removeLabel, placeholder, autoFocus, labels, testIds, }: FolderCommandListProps): import("react").JSX.Element;

package/dist/files/GridView.d.ts

@@ -0,0 +1,59 @@
+/**
+ * GridView — a flexible AG Grid presentational core.
+ *
+ * Pure and app-agnostic: it owns no global state and pulls in no store. Column
+ * state persistence (order / width / visibility / sort / filter) is exposed as a
+ * controlled/uncontrolled prop pair — `gridState` (initial state, read once at
+ * mount) and `onGridStateChange` (called whenever AG Grid's state changes). An
+ * app wires those to wherever it keeps the state (Zustand, localStorage, a URL,
+ * a server) via a thin adapter; the core stays decoupled.
+ *
+ * Themed here (colours/fonts/borders via the host CSS variables, so it inherits the host's
+ * light/dark theme). The structural helper classes (cell-numeric, multiline clamp, scrollbars,
+ * row kebabs) live in `@arbidocs/blocks/grid.css`, which the consuming app imports globally.
+ */
+import React from 'react';
+import { ColDef, GridOptions, GridApi, GridState, CellValueChangedEvent } from 'ag-grid-community';
+export interface GridViewSelection<T> {
+    mode: 'single' | 'multiple';
+    selected: T[];
+    onSelectionChange: (items: T[]) => void;
+}
+export interface GridViewEmptyState {
+    icon?: React.ReactNode;
+    title?: string;
+    message?: string;
+    action?: React.ReactNode;
+}
+export interface GridViewProps<T> {
+    items: T[];
+    columnDefs: ColDef<T>[];
+    getItemId: (item: T) => string;
+    selection?: GridViewSelection<T>;
+    emptyState?: GridViewEmptyState;
+    isLoading?: boolean;
+    loadingMessage?: string;
+    gridOptions?: Partial<GridOptions<T>>;
+    onGridReady?: (params: {
+        api: GridApi<T>;
+    }) => void;
+    onCellValueChanged?: (event: CellValueChangedEvent<T>) => void;
+    onRowClick?: (item: T) => void;
+    persistState?: boolean;
+    gridId?: string;
+    gridState?: GridState;
+    onGridStateChange?: (state: GridState) => void;
+    initialVisibleColumns?: string[];
+    className?: string;
+    height?: string | number;
+    rowHeight?: number;
+    testId?: string;
+    pinnedBottomRowData?: T[];
+    pinnedTopRowData?: T[];
+    pagination?: boolean;
+    paginationPageSizeSelector?: number[];
+    getRowTestId?: (item: T) => string;
+    getCellTestId?: (colId: string, item: T) => string;
+    showEmpty?: boolean;
+}
+export declare function GridView<T>({ items, columnDefs, getItemId, selection, emptyState, isLoading, loadingMessage, gridOptions, onGridReady, onCellValueChanged, onRowClick, persistState, gridState, onGridStateChange, initialVisibleColumns, className, height, rowHeight: rowHeightProp, testId, pinnedBottomRowData, pinnedTopRowData, pagination, paginationPageSizeSelector, getRowTestId, getCellTestId, showEmpty, }: GridViewProps<T>): React.JSX.Element;