@arbidocs/blocks 0.4.159 → 0.4.161

package/dist/connection/files/fields/useFieldsApply.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Apply and Clear for the fields editor: put the checked tags on the target, or take them off. The
+ * target is the host's (`FieldsTarget`, e.g. the selected facts), else documents. On documents an
+ * AI field is generated (asking first before overwriting values already there), a plain one is
+ * attached where it is missing, and clearing detaches it where it is present.
+ */
+import type { TagResponse } from '@arbidocs/sdk/browser';
+/** What Apply / Clear act on when it is not documents (e.g. the selected facts). */
+export interface FieldsTarget {
+    noun: {
+        singular: string;
+        plural: string;
+    };
+    ids: string[];
+    /** Attach every given tag to every target. */
+    apply: (tagIds: string[]) => Promise<void>;
+    /** Detach every given tag from every target. */
+    clear: (tagIds: string[]) => Promise<void>;
+    /** How many of the host's items carry a tag (shown instead of the document count). */
+    countFor?: (tagId: string) => number;
+}
+/** AI fields were put on documents: the tags (in the order shown) and the documents. */
+export interface AppliedAiFields {
+    tags: {
+        id: string;
+        name: string;
+    }[];
+    docIds: string[];
+}
+export declare function useFieldsApply({ tags, nouns, targetNoun, targetIds, target, onAiFieldsApplied, }: {
+    tags: TagResponse[];
+    nouns: {
+        singular: string;
+        plural: string;
+    };
+    targetNoun: {
+        singular: string;
+        plural: string;
+    };
+    targetIds: string[];
+    target?: FieldsTarget;
+    /** AI fields were applied to documents (e.g. show their values). Absent: a message says so. */
+    onAiFieldsApplied?: (result: AppliedAiFields) => void;
+}): {
+    apply: (tagIds: string[]) => Promise<boolean>;
+    clear: (tagIds: string[]) => Promise<boolean>;
+    isApplying: boolean;
+    isClearing: boolean;
+};

package/dist/connection/files/fields/useMemberLookup.d.ts

@@ -0,0 +1,3 @@
+import { type DocumentPerson } from '@arbidocs/react';
+/** Finds a workspace member by id (undefined for anyone else, or no id). */
+export declare function useMemberLookup(): (userId: string | null | undefined) => DocumentPerson | undefined;

package/dist/connection/files/grid/ConnectedTagEntity.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A label or field as a pill, with the rich hover card: its type, how many documents carry it, who
+ * can see it (a toggle for its owner), and who created and last changed it. The pill itself is the
+ * shared `TagEntity` of `@arbidocs/react/ui`; this adds what it reads from the session.
+ */
+import type { TagResponse } from '@arbidocs/sdk/browser';
+export interface ConnectedTagEntityProps {
+    tag: TagResponse;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    onClick?: (e: React.MouseEvent) => void;
+    /** Whether to show the detailed tooltip (default: true) */
+    showTooltip?: boolean;
+    /** Whether current user can edit this tag (owner) */
+    canEdit?: boolean;
+    /** Callback when edit is requested (clicking visibility toggle as owner) */
+    onEditClick?: () => void;
+}
+export declare function ConnectedTagEntity({ tag, size, className, onClick, showTooltip, canEdit, onEditClick, }: ConnectedTagEntityProps): import("react").JSX.Element;

package/dist/connection/files/grid/cells.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The documents table's cell bindings: the document pill with its row menu, who can see it, its
+ * folder, its related documents, its labels and its uploader. The presentation is in `files/`;
+ * these bind it to the session. Writes come in through props or the grid's context, never a hook
+ * per row, so a large table adds no per-row subscriptions beyond what a cell must show.
+ */
+import { type DocumentHostActions, type RelatedDocs, type useAssignDocTags, type useCreateTag, type useRemoveDocTags } from '@arbidocs/react';
+import { type FileTileDocument, type FileTileUser } from '../explorer/FileTiles';
+/** A person as a table cell shows them. */
+export type GridUser = FileTileUser & {
+    is_identity_verified?: boolean | null;
+};
+/** A small avatar for a person (initials, or their picture); opens them when the host can. */
+export declare const UserAvatar: import("react").NamedExoticComponent<{
+    user: GridUser | undefined;
+    isMe?: boolean;
+    onOpen?: (userId: string) => void;
+}>;
+export interface DocumentNameCellProps {
+    doc: FileTileDocument;
+    /** The viewer may rename, move or delete the document. */
+    canEdit: boolean;
+    /** The workspace's members (the hover card's "last modified by"). */
+    users: readonly GridUser[];
+    onOpen: () => void;
+    /** Open in the review view. Absent: not offered. */
+    onReview?: () => void;
+    /** Start a chat about the document. Absent: not offered. */
+    onDocumentChat?: () => void;
+    onRename: () => void;
+    onDownload: () => void;
+    onMove: () => void;
+    onDelete: () => void;
+}
+/**
+ * The Document column: the document pill (exactly as documents look everywhere), opened by a
+ * click, with the offline mark on its icon, its status after the name and the row menu.
+ */
+export declare const DocumentNameCell: import("react").NamedExoticComponent<DocumentNameCellProps>;
+/** Who can see the document: a toggle for its owner. */
+export declare const DocumentSharedCell: import("react").NamedExoticComponent<{
+    document: FileTileDocument;
+    disabled?: boolean;
+    disabledTooltip?: string;
+    onToggle: (docId: string, shared: boolean) => void;
+}>;
+/** The folders documents are in (and `value`), for a folder picker. */
+export declare function useDocumentFolders(documents: readonly {
+    folder?: string | null;
+}[], value?: string | null): string[];
+/** The document's folder, changed by a picker of the workspace's folders. */
+export declare const DocumentFolderCell: import("react").NamedExoticComponent<{
+    document: FileTileDocument;
+    isEditable: boolean;
+    allDocuments: readonly FileTileDocument[];
+    onUpdateFolder: (docId: string, folder: string | null) => void;
+}>;
+/** The document's related documents: its email family, copies, duplicates and near-duplicates. */
+export declare const RelatedDocumentsCell: import("react").NamedExoticComponent<{
+    currentDoc: FileTileDocument;
+    related: RelatedDocs<FileTileDocument>;
+    /** The document open in the viewer (its pill is marked). */
+    viewingDocumentId: string | null;
+    onDocumentClick: (docId: string) => void;
+    onDelete: (doc: FileTileDocument) => void;
+    /** Compare with a similar document. Absent: not offered. */
+    onCompare?: (docId: string, otherDocId: string) => void;
+}>;
+/** A label as the Labels column offers it. */
+export interface GridLabel {
+    external_id: string;
+    name: string;
+}
+/** The document's labels: toggle one, or create one by name and apply it. */
+export declare const DocumentLabelsCell: import("react").NamedExoticComponent<{
+    doc: FileTileDocument;
+    labels: readonly GridLabel[];
+    createDocTag: Pick<ReturnType<typeof useAssignDocTags>, "mutateAsync">;
+    deleteDocTag: Pick<ReturnType<typeof useRemoveDocTags>, "mutateAsync">;
+    createTag: Pick<ReturnType<typeof useCreateTag>, "mutateAsync">;
+    isMember: boolean;
+    /** The row height: the chips are clamped to the rows that fully fit. */
+    rowHeight?: number;
+    actions?: DocumentHostActions;
+}>;

package/dist/connection/files/grid/documentColumns.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The documents table's columns (explicit `colId`s; AG Grid's saved state decides which show and
+ * in what order): the document pill, its status, its AI fields (type, author, abstract, date), its
+ * file facts, folder, sender, fingerprint, related documents, visibility, uploader, labels, id, and
+ * one column per AI field. Writes come in as parameters, the row-independent lookups through the
+ * grid's context, so the columns are rebuilt only when the fields themselves change.
+ */
+import type { ColDef } from 'ag-grid-community';
+import { type TagResponse } from '@arbidocs/sdk/browser';
+import { type DocumentHostActions, type RelatedDocsMap, type useAssignDocTags, type useCreateTag, type useRemoveDocTags, type useUpdateDocTag } from '@arbidocs/react';
+import { type WorkspaceMemberRole } from '../../../files/permissions';
+import type { FileTileDocument } from '../explorer/FileTiles';
+import { type GridUser } from './cells';
+/** A row of the documents table. */
+export type GridDocument = FileTileDocument & {
+    /** The email sender of a document imported from mail ("Ada <ada@x.com>"). */
+    sender?: string | null;
+};
+type Doc = GridDocument;
+type Tag = TagResponse;
+/**
+ * What the columns read through the grid's `context` (row-independent, so the column definitions
+ * stay put when they change).
+ */
+export interface DocumentGridContext {
+    getDocuments?: () => GridDocument[];
+    getRelatedDocs?: () => RelatedDocsMap<GridDocument>;
+    getFamilyMeta?: () => Map<string, {
+        tier: number;
+        count: number;
+    }>;
+    getWorkspaceUsers?: () => GridUser[];
+    getCurrentUserId?: () => string | undefined;
+    getViewingDocumentId?: () => string | null;
+    getHostActions?: () => DocumentHostActions;
+    updateFolder?: (docId: string, folder: string | null) => void;
+}
+interface CreateDocumentColumnsParams {
+    handleToggleDocumentViewer: (docId: string) => void;
+    onStatusClick?: () => void;
+    /** Per-row document actions for the unified name column's ⋯ kebab. */
+    onReviewDocument?: (docId: string) => void;
+    /** Start a new chat scoped to one document, opening it in the side viewer. */
+    onDocumentChat?: (docId: string) => void;
+    onDownloadDocument?: (doc: Doc) => void;
+    onMoveDocument?: (docId: string) => void;
+    onDeleteDocument?: (docId: string) => void;
+    isMember: boolean;
+    /**
+     * The viewer's role in the workspace (null: not a member, e.g. a public workspace's visitor).
+     * Only an owner or a collaborator edits documents someone else created.
+     */
+    workspaceRole: WorkspaceMemberRole | null;
+    currentUserExtId?: string;
+    availableTags: Tag[];
+    createDocTag: Pick<ReturnType<typeof useAssignDocTags>, 'mutateAsync'>;
+    updateDocTag: Pick<ReturnType<typeof useUpdateDocTag>, 'mutateAsync'>;
+    deleteDocTag: Pick<ReturnType<typeof useRemoveDocTags>, 'mutateAsync'>;
+    createTag: Pick<ReturnType<typeof useCreateTag>, 'mutateAsync'>;
+    /** Share a document with the workspace, or make it private. */
+    onToggleShared: (docId: string, shared: boolean) => void;
+    /** How a tag write's outcome is told (the environment's notify). */
+    notify: (message: string, kind: 'success' | 'error') => void;
+}
+export declare function createDocumentColumns({ handleToggleDocumentViewer, onStatusClick, onReviewDocument, onDocumentChat, onDownloadDocument, onMoveDocument, onDeleteDocument, isMember, workspaceRole, currentUserExtId, availableTags, createDocTag, updateDocTag, deleteDocTag, createTag, onToggleShared, notify, }: CreateDocumentColumnsParams): ColDef<Doc>[];
+export {};

package/dist/connection/files/grid/documentGridBus.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Document Grid Bus
+ *
+ * Applies the row changes of every write to the documents list (`@arbidocs/react`
+ * `subscribeDocumentRows`) to the Files AG Grid as `applyTransactionAsync` transactions.
+ *
+ * Why a bus:
+ * - Without it, every cache write cascades through the filters into a full `rowData` diff in AG
+ *   Grid. During a bulk upload of 100 docs that can be hundreds of cascades within seconds.
+ * - applyTransactionAsync coalesces transactions inside a ~60ms window into one render pass, so N
+ *   concurrent document completions collapse to 1-2 grid flushes instead of N full diffs.
+ *
+ * The React Query cache stays the source of truth; when the grid is not mounted (another page)
+ * the changes are simply not applied anywhere. The grid api is registered on onGridReady and
+ * unregistered on unmount (not stored in Zustand: it is not serializable and its mounting must not
+ * re-render anything).
+ */
+import type { GridApi } from 'ag-grid-community';
+import type { DocumentRowChange } from '@arbidocs/react';
+import type { GridDocument as Doc } from './documentColumns';
+/**
+ * Register the Documents grid API. Called from onGridReady.
+ * Subsequent calls replace the previous registration (e.g. on remount).
+ */
+export declare function registerDocumentGridApi(api: GridApi<Doc>): void;
+/**
+ * Unregister the grid API. Called on unmount.
+ * After this, row changes are not applied anywhere.
+ */
+export declare function unregisterDocumentGridApi(api: GridApi<Doc>): void;
+/**
+ * Apply one write's row changes to the grid as a single transaction.
+ *
+ * Adds are not sent: AG Grid's React integration, with `rowData` AND `getRowId` set (the Files grid
+ * sets both), diffs every `rowData` change and queues its OWN add transactions. An add queued here
+ * would collide with AG Grid's for the same id in the same flush window ("Duplicate node id", a
+ * phantom second row), so the `rowData` diff carries adds. An add whose id the grid already holds
+ * (a sibling path raced ahead) is sent as an update so the cell still refreshes.
+ *
+ * Updates are filtered to ids the grid holds: AG Grid logs `error #4: Could not find row id=…` for
+ * every unmatched id (processing events for rows the `rowData` diff has not flushed yet).
+ */
+export declare function applyDocumentRowChange({ add, update, remove }: DocumentRowChange): void;
+/**
+ * Test-only: reset module state between tests.
+ * @internal
+ */
+export declare function __resetDocumentGridBusForTests(): void;

package/dist/connection/files/grid/documentStatus.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A document's status as the table shows it: the live in-flight status the host hears wins over
+ * the row's, an offline edit waiting to sync is its own state, and a failure names its stage. One
+ * resolution feeds both the Status column's pill and the glyph after the document's name, so they
+ * always agree. Each reads only its own document's live processing, so a row re-renders only when
+ * its own status changes.
+ */
+import { type DocumentHostActions, type WorkspaceDocument } from '@arbidocs/react';
+/** A row as the status reads it (the session's rows may carry the failed stage). */
+export type StatusDocument = WorkspaceDocument & {
+    failed_stage?: string | null;
+};
+/** The plan's AI budget a failure ran into, read from its error message. */
+export declare function parseQuotaError(errorMessage: string | null | undefined): {
+    spend: number;
+    budget: number;
+    projectExtId: string | null;
+} | null;
+export interface ResolvedDocStatus {
+    /** The status to show: a live in-flight status wins over a finished one on the row. */
+    status: string;
+    /** An offline edit is waiting to sync (shown over "ready"). */
+    isPendingSync: boolean;
+    /** Where a failure stopped: live, else on the row. */
+    failedStage: string | null;
+}
+/** The status a document shows now (null while it has none). */
+export declare function useResolvedDocStatus(doc: StatusDocument | undefined): ResolvedDocStatus | null;
+/**
+ * The quiet status mark after a document's name, so the table needs no Status column: a ready
+ * document shows nothing; work in flight, waiting and problems get a glyph with a title. The spinner
+ * is a CSS animation, so a table of processing rows costs no timers.
+ */
+export declare const DocumentStatusGlyph: import("react").NamedExoticComponent<{
+    doc: StatusDocument;
+}>;
+/** The Status column: a tinted pill per status, with a progress bar while processing. */
+export declare const StatusCell: import("react").NamedExoticComponent<{
+    doc: StatusDocument | undefined;
+    /** Opens the host's processing details. */
+    onStatusClick?: () => void;
+    actions?: DocumentHostActions;
+}>;

package/dist/connection/files/grid/familyMeta.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Tiered sort metadata per family group, keyed by the same groupId the
+ * Related-column valueGetter computes. Family tier = the highest-priority
+ * relationship type *anywhere* in the family, so a parent's duplicate
+ * status promotes its whole family. Within a tier, the count is the
+ * aggregate of that relationship type across family members.
+ *
+ *   tier 3 — any member has duplicates  → count = Σ duplicates.length
+ *   tier 2 — any member has similar     → count = Σ similar.length
+ *   tier 1 — pure parent/child family   → count = family member count
+ *   tier 0 — no relationships at all    → count = 0
+ *
+ * Higher tier first under descending sort puts dupes → similar → family
+ * → none, matching what the user expects when clicking the column header.
+ */
+import type { RelatedDocsMap, WorkspaceDocument } from '@arbidocs/react';
+export type FamilyMeta = Map<string, {
+    tier: number;
+    count: number;
+}>;
+export declare function documentFamilyMeta<D extends WorkspaceDocument>(documents: D[], relatedDocsMap: RelatedDocsMap<D>): FamilyMeta;

package/dist/connection/files/grid/tagColumn.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Unified tag column factory - creates AG Grid column definitions for all tag types
+ * Text/Number tags: Show note with inline editing
+ * Select tags: Show multiselect dropdown inline editor
+ * Presence tags (label, issue, person, organisation): Show checkbox for simple toggle
+ */
+import { type TagResponse } from '@arbidocs/sdk/browser';
+import type { ColDef } from 'ag-grid-community';
+import type { useAssignDocTags, useRemoveDocTags, useUpdateDocTag } from '@arbidocs/react';
+import type { FileTileDocument as Doc } from '../explorer/FileTiles';
+type Tag = TagResponse;
+type Notify = (message: string, kind: 'success' | 'error') => void;
+interface CreateTagColumnParams {
+    tag: Tag;
+    isMember: boolean;
+    /** How a write's outcome is told (the environment's notify). */
+    notify: Notify;
+    createDocTag: Pick<ReturnType<typeof useAssignDocTags>, 'mutateAsync'>;
+    updateDocTag: Pick<ReturnType<typeof useUpdateDocTag>, 'mutateAsync'>;
+    deleteDocTag: Pick<ReturnType<typeof useRemoveDocTags>, 'mutateAsync'>;
+}
+export declare function createTagColumn({ tag, isMember, notify, createDocTag, updateDocTag, deleteDocTag, }: CreateTagColumnParams): ColDef<Doc>;
+export {};

package/dist/connection/files/grid/useDocumentGridSync.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The documents table's AG Grid wiring, bound to the session: owns the grid api, applies every
+ * write to the open workspace's list as one row transaction (the cache stays the source of truth),
+ * keeps the grid's selection in step with the host's, filters with a set of visible ids instead of
+ * swapping `rowData`, and builds the grid options with the context the cells read.
+ */
+import type { ColDef, GridApi, IRowNode } from 'ag-grid-community';
+import { type RelatedDocsMap } from '@arbidocs/react';
+import type { DocumentGridContext, GridDocument } from './documentColumns';
+import type { GridUser } from './cells';
+type Doc = GridDocument;
+export interface UseDocumentGridSyncArgs {
+    /** Every document of the workspace (the grid holds them all). */
+    documents: Doc[];
+    /** The ones the filters let through. */
+    filteredDocuments: Doc[];
+    columnDefs: ColDef<Doc>[];
+    relatedDocsMap: RelatedDocsMap<Doc>;
+    workspaceUsers: GridUser[];
+    selectedDocumentIds: readonly string[];
+    setSelectedDocumentIds: (ids: string[]) => void;
+    handleColumnStateChange: () => void;
+    updateFolder: (docId: string, folder: string | null) => void;
+    /** Told of the grid api as it mounts (and null as it goes), e.g. for end-to-end helpers. */
+    onGridApi?: (api: GridApi<Doc> | null) => void;
+}
+export declare function useDocumentGridSync({ documents, filteredDocuments, columnDefs, relatedDocsMap, workspaceUsers, selectedDocumentIds, setSelectedDocumentIds, handleColumnStateChange, updateFolder, onGridApi, }: UseDocumentGridSyncArgs): {
+    gridApiRef: import("react").RefObject<GridApi<GridDocument> | null>;
+    gridApi: GridApi<GridDocument> | null;
+    gridReadyTick: number;
+    gridOptions: {
+        suppressMultiSort: boolean;
+        suppressMenuHide: boolean;
+        maintainColumnOrder: boolean;
+        suppressColumnVirtualisation: boolean;
+        onColumnMoved: () => void;
+        onColumnVisible: () => void;
+        isExternalFilterPresent: () => boolean;
+        doesExternalFilterPass: (node: IRowNode<Doc>) => boolean;
+        context: DocumentGridContext;
+    };
+    handleGridReady: (params: {
+        api: GridApi<Doc>;
+    }) => void;
+    handleSelectionChange: (docs: Doc[]) => void;
+    handleClearSelection: () => void;
+};
+export {};

package/dist/connection/files/grid/useDocumentTable.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The documents table's columns and edits, bound to the session: the column definitions (rebuilt
+ * only when the fields themselves change, so AG Grid keeps manual column widths), the inline edits
+ * (title, AI fields, folder) written through `@arbidocs/react`, and the default columns.
+ */
+import type { CellValueChangedEvent, ColDef } from 'ag-grid-community';
+import type { WorkspaceMemberRole } from '../../../files/permissions';
+import { type GridDocument } from './documentColumns';
+type Doc = GridDocument;
+interface DocumentTableProps {
+    handleToggleDocumentViewer: (docId: string) => void;
+    /** The viewer's id and role in the workspace (who may edit what). */
+    currentUserExtId?: string;
+    workspaceRole: WorkspaceMemberRole | null;
+    onStatusClick?: () => void;
+    onReviewDocument?: (docId: string) => void;
+    onDownloadDocument?: (doc: Doc) => void;
+    onMoveDocument?: (docId: string) => void;
+    onDeleteDocument?: (docId: string) => void;
+    isMember?: boolean;
+    documents?: Doc[];
+}
+export declare function useDocumentTable({ handleToggleDocumentViewer, onStatusClick, onReviewDocument, onDownloadDocument, onMoveDocument, onDeleteDocument, isMember, currentUserExtId, workspaceRole, }: DocumentTableProps): {
+    columnDefs: ColDef<GridDocument, any>[];
+    onCellValueChanged: (event: CellValueChangedEvent<Doc>) => Promise<void>;
+    handleColumnStateChange: () => void;
+    defaultVisibleColumns: string[];
+    updateFolder: (externalId: string, folder: string | null) => void;
+};
+export {};

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

@@ -1,10 +1,44 @@
 export { ConnectedFilesExplorer, TILE_DEFAULT, TILE_MAX, TILE_MIN, type ConnectedFilesExplorerHandle, type ConnectedFilesExplorerProps, } from './explorer/ConnectedFilesExplorer';
 export { FileTooltipContent, isActiveDocumentStatus, startMenuItem, type FileTileDocument, type FileTileUser, } from './explorer/FileTiles';
 export { DocumentSyncGlyph } from './DocumentSyncGlyph';
-export { FilesSupportProvider, useFilesSupport, useOfflineDocumentIds, useViewingDocumentId, type FilesStartItem, type FilesSupport, } from './support';
-export { useFilesStore, usePendingFolders } from './store';
+export { useFilesPrefs, useFilesStore, usePendingFolders } from './store';
 export { ConnectedUpload, type ConnectedUploadFooterParts, type ConnectedUploadProps, } from './upload/ConnectedUpload';
 export { ConnectedUploadDropzone, type ConnectedUploadDropzoneProps, type UploadSource, } from './upload/ConnectedUploadDropzone';
 export { EmptyWorkspaceUpload, type EmptyWorkspaceUploadProps } from './upload/EmptyWorkspaceUpload';
 export { AddFromAccountsButton } from './upload/AddFromAccountsButton';
 export { useAddFromUrls, type AddFromUrlsOptions } from './upload/useAddFromUrls';
+export { useDocumentTable } from './grid/useDocumentTable';
+export { createDocumentColumns, type DocumentGridContext, type GridDocument, } from './grid/documentColumns';
+export { createTagColumn } from './grid/tagColumn';
+export { DocumentFolderCell, DocumentLabelsCell, DocumentNameCell, DocumentSharedCell, RelatedDocumentsCell, UserAvatar, useDocumentFolders, type GridLabel, type GridUser, } from './grid/cells';
+export { DocumentStatusGlyph, StatusCell, parseQuotaError, useResolvedDocStatus, type ResolvedDocStatus, } from './grid/documentStatus';
+export { ConnectedTagEntity, type ConnectedTagEntityProps } from './grid/ConnectedTagEntity';
+export { ConnectedFilesBulkActions, type ConnectedFilesBulkActionsProps, } from './bulk/ConnectedFilesBulkActions';
+export { useDocumentBulkActions, BULK_REPROCESS_LIMIT } from './bulk/useDocumentBulkActions';
+export { useDocumentGridSync, type UseDocumentGridSyncArgs } from './grid/useDocumentGridSync';
+export { documentFamilyMeta, type FamilyMeta } from './grid/familyMeta';
+export { useDocumentFilters, deduplicateByContentHash, DEFAULT_SEARCH_FIELDS, SEARCH_FIELD_OPTIONS, type DocumentFilterId, type DocumentFilterOption, type SearchFieldId, } from './useDocumentFilters';
+export { ConnectedAiReview, type ConnectedAiReviewProps } from './review/ConnectedAiReview';
+export { reviewProgress } from './review/reviewProgress';
+export { useAiReviewStore, type AiReviewRun } from './store';
+export { ConnectedMoveToFolder, type ConnectedMoveToFolderProps, } from './move/ConnectedMoveToFolder';
+export { ConnectedTagForm, type ConnectedTagFormProps, type TagCreateData, type TagFormat, type TagUpdateData, } from './fields/ConnectedTagForm';
+export { ConnectedTagEditorDialog, type ConnectedTagEditorDialogProps, } from './fields/ConnectedTagEditorDialog';
+export { ConnectedFieldsEditor, type ConnectedFieldsEditorProps, type FieldsExportSlot, } from './fields/ConnectedFieldsEditor';
+export { ConnectedFieldsManager, type ConnectedFieldsManagerProps, } from './fields/ConnectedFieldsManager';
+export { type AppliedAiFields, type FieldsTarget } from './fields/useFieldsApply';
+export { ConnectedBulkTagEditor, type ConnectedBulkTagEditorProps, } from './fields/ConnectedBulkTagEditor';
+export { documentFieldContent, type DocTagCitations, type DocumentFieldContent, type DocumentFieldOptions, } from './fields/documentField';
+export { DocumentUser } from './fields/DocumentUser';
+export { useMemberLookup } from './fields/useMemberLookup';
+export { useFilesGridStates, type FilesViewMode } from './store';
+export { DocumentsFilterBarActions, type DocumentsFilterBarActionsProps, } from './page/DocumentsFilterBarActions';
+export { DocumentsUploadButton, type DocumentsUploadButtonProps, } from './page/DocumentsUploadButton';
+export { PersistedGridView } from './page/PersistedGridView';
+export { ProgressiveLoadingChip } from './page/ProgressiveLoadingChip';
+export { useDocumentNavigation } from './page/useDocumentNavigation';
+export { ViewSelector, type LoadableTableView } from './views/ViewSelector';
+export { useTableViews } from './views/useTableViews';
+export { viewsOfTable, withMissingTableViews, withTableView, withoutTableView, type TableView, type TableViewTable, } from './views/tableViews';
+export { useFilesDialogs, type DeleteRequestDocument } from './store';
+export { ConnectedFilesPage, type ConnectedFilesPageProps, type FilesReviewCardProps, type FilesUploadRequest, } from './page/ConnectedFilesPage';

package/dist/connection/files/move/ConnectedMoveToFolder.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MoveToFolderModal Component
+ *
+ * Dialog for moving selected documents (or an entire folder) to a folder.
+ * The folder picker is searchable and scrollable, and creates a folder from what is typed.
+ *
+ * File mode  — selectedDocuments non-empty, folderToMove null:
+ *   Sets folder = targetFolder for every selected doc (flat move, existing behaviour).
+ *
+ * Folder mode — folderToMove non-empty:
+ *   Moves the folder itself into targetFolder, preserving sub-structure.
+ *   E.g. moving "Reports/Q1" into "Archive" renames each doc's folder prefix:
+ *     Reports/Q1        → Archive/Q1
+ *     Reports/Q1/Sub    → Archive/Q1/Sub
+ */
+import { type WorkspaceDocument } from '@arbidocs/react';
+import { type ExplorerFolder } from '../../../files/folders';
+type Doc = WorkspaceDocument;
+export interface ConnectedMoveToFolderProps {
+    isOpen: boolean;
+    onClose: () => void;
+    selectedDocuments: Doc[];
+    /** When set, move the folder itself (with structure) instead of flat-moving selectedDocuments. */
+    folderToMove?: ExplorerFolder | null;
+    /** All workspace documents — needed to find folder contents in folder mode. */
+    documents?: Doc[];
+    /** Called after a successful file-mode move, e.g. to clear the now-stale selection. */
+    onMoved?: () => void;
+}
+export declare function ConnectedMoveToFolder({ isOpen, onClose, selectedDocuments, folderToMove, documents, onMoved, }: ConnectedMoveToFolderProps): import("react").JSX.Element;
+export {};

package/dist/connection/files/page/ConnectedFilesPage.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The workspace's files, bound to the session: the documents as a table, an explorer, a review one
+ * at a time, or the host's search; filters, the folder picker, saved views and density; the bulk
+ * bar; moving, AI review and deleting. Selection, the document in view and the conversation's
+ * documents are the session's (`useArbiSessionState`), the view and density are kept on this
+ * device. The host opens its viewer, its upload dialog and its own dialogs (export, production, a
+ * new draft), and may slot in its review card, fields manager, bulk tag editor and search.
+ */
+import { type ComponentType, type ReactNode } from 'react';
+import type { GridApi } from 'ag-grid-community';
+import { type RelatedDocsMap } from '@arbidocs/react';
+import type { GridViewProps } from '../../../files/GridView';
+import type { GridDocument } from '../grid/documentColumns';
+import type { UploadSource } from '../upload/ConnectedUploadDropzone';
+type Doc = GridDocument;
+/** What the host's review card is handed (review mode shows one document at a time). */
+export interface FilesReviewCardProps {
+    currentDocument: Doc;
+    documents: Doc[];
+    gridId: string;
+    gridApi: GridApi<Doc>;
+    onNavigate: (docId: string) => void;
+    onOpenDocumentViewer: (docId?: string) => void;
+    onDeleteDocument: (docId: string) => void;
+    isDocumentViewerEnabled: boolean;
+    onReorderColumns: (newOrder: string[]) => void;
+    currentIndex: number;
+    onPrevious: () => void;
+    onNext: () => void;
+}
+/** An upload the host's dialog starts: files chosen here, or a source to pick from. */
+export interface FilesUploadRequest {
+    source: UploadSource;
+    files?: File[];
+    folder?: string | null;
+}
+export interface ConnectedFilesPageProps {
+    /** In a dialog: the table only, with a Close footer. */
+    isModal?: boolean;
+    onClose?: () => void;
+    /** Open a document in the host's viewer; the open one again closes it. */
+    onToggleDocument: (docId?: string) => void;
+    /** Open the host's upload dialog. */
+    onUpload: (request: FilesUploadRequest) => void;
+    /** Open the host's processing details (a status was clicked). */
+    onStatusClick?: () => void;
+    /** Open the host's tags page. Absent: no Tags button. */
+    onOpenTags?: () => void;
+    /** Open the host's export dialog for the selection. */
+    onExport: () => void;
+    /** Open the host's production dialog. Absent: not offered. */
+    onProduce?: () => void;
+    /** The Add menu's host entries. */
+    onEmailWorkspace?: () => void;
+    onCreateNew?: () => void;
+    onTakePhoto?: () => void;
+    /** Beside the filters (e.g. the recently-deleted button). */
+    headerExtras?: ReactNode;
+    /** The workspace's icon in dialog titles. */
+    workspaceIcon?: ReactNode;
+    /** A free-text filter coming from elsewhere (the page's own box wins while it has text). */
+    externalSearchQuery?: string;
+    /** The host's search view (the "search" view mode). Absent: no search view. */
+    renderSearch?: () => ReactNode;
+    /** The host's review card (the "navigator" view mode). */
+    renderReviewCard?: (props: FilesReviewCardProps) => ReactNode;
+    /** The host's fields manager (columns and fields). */
+    renderFieldsManager?: (props: {
+        getGridApi: () => GridApi<Doc> | null;
+        onReorderColumns: (ids: string[], gridApi?: GridApi<Doc>) => void;
+    }) => ReactNode;
+    /** Above the bulk label and field editor (e.g. where the user is). */
+    bulkTagBreadcrumb?: ReactNode;
+    /** The host's own dialogs (export, production, a new draft, mailing the workspace). */
+    dialogs?: ReactNode;
+    /** The grid with the host's column-state persistence (default: kept on this device). */
+    GridComponent?: ComponentType<GridViewProps<Doc>>;
+    /** Changes whenever that grid state does (the saved-views menu recomputes). */
+    gridStateVersion?: unknown;
+    /** Told of the grid api (e.g. for end-to-end helpers). */
+    onGridApi?: (api: GridApi<Doc> | null) => void;
+    /** Told of the related-documents map (e.g. for the host's viewer). */
+    onRelatedDocsChange?: (map: RelatedDocsMap<Doc>) => void;
+}
+export declare function ConnectedFilesPage({ isModal, onClose, onToggleDocument, onUpload, onStatusClick, onOpenTags, onExport, onProduce, onEmailWorkspace, onCreateNew, onTakePhoto, headerExtras, workspaceIcon, externalSearchQuery, renderSearch, renderReviewCard, renderFieldsManager, bulkTagBreadcrumb, dialogs, GridComponent, gridStateVersion, onGridApi, onRelatedDocsChange, }: ConnectedFilesPageProps): import("react").JSX.Element;
+export {};