@arbidocs/blocks 0.3.184 → 0.4.0

package/dist/files/page/FilesAddMenu.d.ts

@@ -0,0 +1,30 @@
+import type { LucideIcon } from 'lucide-react';
+export interface FilesAddMenuItem {
+    id: string;
+    label: string;
+    icon: LucideIcon;
+    onSelect: () => void;
+    testId?: string;
+    /** Draws a separator above this item (groups the "add now" sources from the rest). */
+    separatorBefore?: boolean;
+}
+export interface FilesAddMenuProps {
+    items: FilesAddMenuItem[];
+    /** Hide the "Add" label (narrow headers); the icon and chevron stay. */
+    isCompact?: boolean;
+    /** When false the trigger is disabled and `disabledReason` is shown as a tooltip. */
+    canAdd?: boolean;
+    disabledReason?: string;
+    size?: 'default' | 'sm';
+    /** Trigger text (default "Add"). */
+    label?: string;
+    className?: string;
+    /** Overrides the trigger test id (default `documents-upload-button`). */
+    testId?: string;
+}
+/**
+ * The page's single primary "Add" control: a source-picker dropdown. Opens on hover (enhancement)
+ * AND on click/tap/keyboard, so it is never hover-only; closes on pointer-out with a short grace
+ * delay so crossing the trigger-to-menu gap does not flicker it shut.
+ */
+export declare function FilesAddMenu({ items, isCompact, canAdd, disabledReason, size, label, className, testId, }: FilesAddMenuProps): import("react").JSX.Element;

package/dist/files/page/FilesPageParts.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentProps, ReactNode } from 'react';
+/** Row of controls that follows the tab: filter field, folder picker, tags button. */
+export declare function FilesFilterBar({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export interface FilesTagsButtonProps {
+    onClick: () => void;
+    /** Button text (default "Tags"). */
+    label?: string;
+    className?: string;
+    /** Overrides the test id (default `filter-bar-tags-button`). */
+    testId?: string;
+}
+/** Opens the labels / annotations vocabulary editor. The label collapses to sr-only on phones. */
+export declare function FilesTagsButton({ onClick, label, className, testId, }: FilesTagsButtonProps): import("react").JSX.Element;
+/**
+ * The view switch beside the page title. Marks a size container so the switch collapses its labels
+ * to icons by the room it is given (not the viewport), and shrinks with the row.
+ */
+export declare function FilesViewCenter({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export interface FilesModalFooterProps {
+    children?: ReactNode;
+    className?: string;
+}
+/** Footer row used when the page is hosted in a modal. */
+export declare function FilesModalFooter({ children, className }: FilesModalFooterProps): import("react").JSX.Element;

package/dist/files/page/FilesPageTitle.d.ts

@@ -0,0 +1,24 @@
+export interface FilesPageTitleProps {
+    /** Page name (default "Files"). */
+    label?: string;
+    /** Number of files after filtering. */
+    count: number;
+    /** Filters are narrowing the list: the count is "of the filtered set". */
+    isFiltered?: boolean;
+    /** The workspace is still indexing files. */
+    isProcessing?: boolean;
+    /** Makes the title a button (e.g. back to the last file view from Smart Search). */
+    onClick?: () => void;
+    /** Word shown after the count while filtered (default "filtered"). */
+    filteredLabel?: string;
+    className?: string;
+    /** Overrides the title test id (default `documents-tab`). */
+    testId?: string;
+    /** Overrides the count test id (default `tab-count`). */
+    countTestId?: string;
+}
+/**
+ * The Files page title: "Files" with the file count as a quiet pill. Replaces the old single
+ * header tab; it is the page's heading, so the one primary action (Add) can sit opposite it.
+ */
+export declare function FilesPageTitle({ label, count, isFiltered, isProcessing, onClick, filteredLabel, className, testId, countTestId, }: FilesPageTitleProps): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+export { FilesAddMenu, type FilesAddMenuItem, type FilesAddMenuProps } from './FilesAddMenu';
+export { FilesPageTitle, type FilesPageTitleProps } from './FilesPageTitle';
+export { FilesFilterBar, FilesModalFooter, FilesTagsButton, FilesViewCenter, type FilesModalFooterProps, type FilesTagsButtonProps, } from './FilesPageParts';

package/dist/files/tags/BulkTagEditor.d.ts

@@ -0,0 +1,136 @@
+import type { ReactNode } from 'react';
+/** One field row of the bulk editor, resolved by the host from the selection and pending edits. */
+export interface BulkTagRow {
+    id: string;
+    /** Field pill (host-rendered). */
+    badge: ReactNode;
+    type: 'checkbox' | 'select' | 'number' | 'text';
+    /** Switch / select / input colour. */
+    color: string;
+    options?: string[];
+    /** AI instruction; a field that has one can be generated. */
+    instruction?: string | null;
+    /** How many of the selected documents already have a value. */
+    currentCount: number;
+    /** Some but not all selected documents have it. */
+    isMixed: boolean;
+    /** Checkbox fields: resolved state after pending edits. */
+    checkboxState: 'checked' | 'unchecked' | 'mixed';
+    /** Select/number/text fields: pending value ('' when none or when clearing). */
+    value: string;
+    /** The field is pending removal from all selected documents. */
+    isClearing: boolean;
+    /** Tick box for AI generation. */
+    isSelectedForGeneration: boolean;
+    hasPendingChange: boolean;
+}
+export interface BulkTagEditorLabels {
+    /** "Custom {entity}" new-field button text. */
+    newField: string;
+    empty: string;
+    /** Screen-reader description of the dialog. */
+    description: string;
+    annotate: string;
+    selected: (count: number) => string;
+    haveValues: (current: number, total: number) => string;
+    enterValue: string;
+    clear: string;
+    aiInstruction: string;
+    selectForGeneration: string;
+    generateWithAi: string;
+    clearing: string;
+    cancel: string;
+    apply: string;
+}
+export declare const DEFAULT_BULK_TAG_EDITOR_LABELS: BulkTagEditorLabels;
+export interface BulkTagEditorTestIds {
+    dialog: string;
+    selectAllAi: string;
+    generate: string;
+    newField: string;
+    cancel: string;
+    apply: string;
+    /** Replaces the whole `select-ai-<id>` id. */
+    selectAi: (id: string) => string;
+}
+export interface BulkTagEditorDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** Breadcrumb in the title (workspace / page); rendered before "Annotate". */
+    breadcrumb?: ReactNode;
+    selectedCount: number;
+    rows: BulkTagRow[];
+    labels?: Partial<BulkTagEditorLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<BulkTagEditorTestIds>;
+    onToggleCheckbox: (id: string) => void;
+    onChangeValue: (id: string, value: string) => void;
+    onToggleClear: (id: string) => void;
+    onToggleGeneration: (id: string) => void;
+    /** AI generation bar (all generatable fields). */
+    generation?: {
+        allSelected: boolean;
+        selectedCount: number;
+        isBusy: boolean;
+        isClearing: boolean;
+        onToggleAll: () => void;
+        onGenerate: () => void;
+    };
+    onNewField: () => void;
+    onCancel: () => void;
+    onApply: () => void;
+    canApply: boolean;
+}
+/**
+ * BulkTagEditorDialog: set, clear or AI-generate field values across the selected documents.
+ * Presentational: the host resolves rows from the selection and owns apply / generate logic.
+ */
+export declare function BulkTagEditorDialog({ open, onClose, breadcrumb, selectedCount, rows, labels: labelOverrides, testIds, onToggleCheckbox, onChangeValue, onToggleClear, onToggleGeneration, generation, onNewField, onCancel, onApply, canApply, }: BulkTagEditorDialogProps): import("react").JSX.Element;
+/** Every fixed string of the replace dialog. Pass a partial `labels` to translate or reword. */
+export interface BulkReplaceLabels {
+    title: string;
+    description: (replaceCount: number, documentCount: number) => string;
+    hideDetails: string;
+    showDetails: string;
+    document: string;
+    replaceOn: (field: string, doc: string) => string;
+    currentValue: string;
+    selectedToReplace: (count: number) => string;
+    selectAll: string;
+    selectNone: string;
+    cancel: string;
+    generate: string;
+}
+export declare const DEFAULT_BULK_REPLACE_LABELS: BulkReplaceLabels;
+/** A selected document and, per generating field, its existing value (undefined = empty). */
+export interface BulkReplaceDocRow {
+    id: string;
+    title: string;
+    /** fieldId -> existing value preview; absent key = nothing to replace. */
+    existing: Record<string, string>;
+}
+export interface BulkReplaceDialogProps {
+    open: boolean;
+    onClose: () => void;
+    /** Number of existing values that will be replaced. */
+    replaceCount: number;
+    documentCount: number;
+    fields: Array<{
+        id: string;
+        name: string;
+    }>;
+    docs: BulkReplaceDocRow[];
+    /** Set of `${docId}:${fieldId}` pairs ticked for replacement. */
+    selectedPairs: Set<string>;
+    showDetails: boolean;
+    onToggleDetails: () => void;
+    onTogglePair: (docId: string, fieldId: string) => void;
+    onSelectAll: () => void;
+    onSelectNone: () => void;
+    isBusy: boolean;
+    isClearing: boolean;
+    onConfirm: () => void;
+    labels?: Partial<BulkReplaceLabels>;
+}
+/** "Replace existing values?" dialog with a collapsible document x field matrix. */
+export declare function BulkReplaceDialog({ open, onClose, replaceCount, documentCount, fields, docs, selectedPairs, showDetails, onToggleDetails, onTogglePair, onSelectAll, onSelectNone, isBusy, onConfirm, isClearing, labels, }: BulkReplaceDialogProps): import("react").JSX.Element;

package/dist/files/tags/DocTagPopover.d.ts

@@ -0,0 +1,113 @@
+import type { ComponentProps, ReactNode } from 'react';
+/** Every fixed string of the document tag popover parts. Pass a partial `labels` to translate or reword. */
+export interface DocTagLabels {
+    annotations: string;
+    previousDocument: string;
+    nextDocument: string;
+    removeTag: (name: string) => string;
+    addTag: (name: string) => string;
+    addNote: string;
+    noneYet: (pluralLower: string) => string;
+    create: (singularLower: string) => string;
+    createNew: (singularLower: string) => string;
+    unsavedChanges: string;
+    cancel: string;
+    apply: string;
+}
+export declare const DEFAULT_DOC_TAG_LABELS: DocTagLabels;
+/** A field (tag) the popover can edit. `type` drives the control; `color` the icon chip. */
+export interface DocTagField {
+    id: string;
+    name: string;
+    type: string;
+    color: string;
+    /** Options of a `select` field. */
+    options?: string[];
+}
+/** Small coloured chip with the field type's icon. */
+export declare function DocTagFieldIcon({ type, color, size, }: {
+    type: string;
+    color: string;
+    size?: number;
+}): import("react").JSX.Element;
+export interface DocTagPopoverProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The trigger element (wrapped in a span). */
+    trigger: ReactNode;
+    /** Header content (breadcrumb and document navigator). */
+    header: ReactNode;
+    /** Footer, shown only when set (unsaved changes). */
+    footer?: ReactNode;
+    children: ReactNode;
+    /** Test id of the popover content (none by default). */
+    testId?: string;
+}
+/** Popover shell for editing one document's fields: header, scrolling body, optional footer. */
+export declare function DocTagPopover({ open, onOpenChange, trigger, header, footer, children, testId, }: DocTagPopoverProps): import("react").JSX.Element;
+export interface DocTagBreadcrumbProps {
+    /** Workspace icon, rendered before the title. */
+    workspaceIcon?: ReactNode;
+    title: string;
+    /** Trailing crumb; wins over `labels.annotations`. */
+    trail?: string;
+    labels?: Partial<DocTagLabels>;
+}
+/** "workspace / Document title / Annotations". */
+export declare function DocTagBreadcrumb({ workspaceIcon, title, trail, labels }: DocTagBreadcrumbProps): import("react").JSX.Element;
+export interface DocTagNavigatorProps {
+    currentId: string;
+    currentTitle: string;
+    items: Array<{
+        id: string;
+        title: string;
+    }>;
+    currentIndex: number;
+    onSelect: (id: string) => void;
+    onPrevious: () => void;
+    onNext: () => void;
+    labels?: Partial<DocTagLabels>;
+}
+/** Document picker with previous/next, so several documents can be annotated in a row. */
+export declare function DocTagNavigator({ currentId, currentTitle, items, currentIndex, onSelect, onPrevious, onNext, labels, }: DocTagNavigatorProps): import("react").JSX.Element;
+export interface DocTagToggleProps extends Omit<ComponentProps<'button'>, 'onChange' | 'onToggle'> {
+    name: string;
+    color: string;
+    checked: boolean;
+    onToggle: (checked: boolean) => void;
+    /** Tooltip shown while disabled. */
+    disabledTooltip?: string;
+    showLabel?: boolean;
+    labels?: Partial<DocTagLabels>;
+}
+/** Checkbox pill for a checkbox-type field: a coloured box on the left and the name. */
+export declare function DocTagToggle({ name, color, checked, onToggle, disabled, disabledTooltip, showLabel, labels, className, ...props }: DocTagToggleProps): import("react").JSX.Element;
+export interface DocTagFieldRowProps {
+    field: DocTagField;
+    value: string;
+    onChange: (value: string) => void;
+    labels?: Partial<DocTagLabels>;
+}
+/** A select / number / text field: icon + name above its input. */
+export declare function DocTagFieldRow({ field, value, onChange, labels }: DocTagFieldRowProps): import("react").JSX.Element;
+/** The input matching a field's type. */
+export declare function DocTagValueInput({ field, value, onChange, labels }: DocTagFieldRowProps): import("react").JSX.Element;
+export interface DocTagEmptyProps {
+    /** Plural entity label, e.g. "Fields". */
+    pluralLabel: string;
+    /** Singular entity label, e.g. "Field". */
+    singularLabel: string;
+    onCreate: () => void;
+    labels?: Partial<DocTagLabels>;
+}
+/** Shown when the workspace has no fields yet. */
+export declare function DocTagEmpty({ pluralLabel, singularLabel, onCreate, labels }: DocTagEmptyProps): import("react").JSX.Element;
+/** "Create new field" link under the field list. */
+export declare function DocTagCreateLink({ singularLabel, onCreate, labels, }: Pick<DocTagEmptyProps, 'singularLabel' | 'onCreate' | 'labels'>): import("react").JSX.Element;
+export interface DocTagUnsavedFooterProps {
+    onCancel: () => void;
+    onApply: () => void;
+    labels?: Partial<DocTagLabels>;
+}
+/** Footer shown while select/number/text fields hold unsaved changes. */
+export declare function DocTagUnsavedFooter({ onCancel, onApply, labels }: DocTagUnsavedFooterProps): import("react").JSX.Element;

package/dist/files/tags/TagManager.d.ts

@@ -0,0 +1,54 @@
+import type { ComponentProps, ReactNode } from 'react';
+/** Every fixed string of the tag manager. Pass a partial `labels` to translate or reword. */
+export interface TagManagerLabels {
+    addNew: (singular: string) => string;
+    newField: string;
+    zeroItems: string;
+    item: string;
+    items: string;
+    delete: string;
+    none: (pluralLower: string) => string;
+    close: string;
+}
+export declare const DEFAULT_TAG_MANAGER_LABELS: TagManagerLabels;
+/** One existing field row of the tag manager. */
+export interface TagManagerItem {
+    id: string;
+    /** Number of documents that use the field. */
+    usageCount: number;
+    /** Only the creator may delete the field. */
+    canDelete: boolean;
+    isEditing: boolean;
+    /** The field's pill (host-rendered so it can carry the rich tooltip). */
+    badge: ReactNode;
+    /** Share toggle, rendered next to the usage count. */
+    visibilityToggle?: ReactNode;
+    /** Inline edit form, rendered while `isEditing`. */
+    form?: ReactNode;
+}
+export interface TagManagerProps extends Omit<ComponentProps<'div'>, 'children'> {
+    items: TagManagerItem[];
+    /** Singular entity label, e.g. "Field". */
+    singularLabel: string;
+    /** Plural entity label, e.g. "Fields". */
+    pluralLabel: string;
+    isCreating: boolean;
+    /** The inline create form, rendered while `isCreating`. */
+    createForm?: ReactNode;
+    /** Colour of the placeholder pill shown while creating. */
+    placeholderColor: string;
+    onStartCreate: () => void;
+    onCancel: () => void;
+    onToggleItem: (id: string) => void;
+    onDeleteItem: (id: string) => void;
+    /** Renders a footer "Close" button when set. */
+    onClose?: () => void;
+    labels?: Partial<TagManagerLabels>;
+    /** Overrides the per-row delete button test id (default `tag-editor-delete-button`). */
+    deleteTestId?: string;
+}
+/**
+ * TagManager: the list of a workspace's custom fields with an "Add new" row on top, expandable
+ * inline edit forms and a usage count per field. Presentational: the host owns the forms.
+ */
+export declare function TagManager({ items, singularLabel, pluralLabel, isCreating, createForm, placeholderColor, onStartCreate, onCancel, onToggleItem, onDeleteItem, onClose, labels, deleteTestId, className, ...props }: TagManagerProps): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+export { TagManager, DEFAULT_TAG_MANAGER_LABELS, type TagManagerItem, type TagManagerLabels, type TagManagerProps, } from './TagManager';
+export { DocTagBreadcrumb, DocTagCreateLink, DocTagEmpty, DocTagFieldIcon, DocTagFieldRow, DocTagNavigator, DocTagPopover, DocTagToggle, DocTagUnsavedFooter, DocTagValueInput, DEFAULT_DOC_TAG_LABELS, type DocTagLabels, type DocTagBreadcrumbProps, type DocTagEmptyProps, type DocTagField, type DocTagFieldRowProps, type DocTagNavigatorProps, type DocTagPopoverProps, type DocTagToggleProps, type DocTagUnsavedFooterProps, } from './DocTagPopover';
+export { BulkReplaceDialog, BulkTagEditorDialog, DEFAULT_BULK_REPLACE_LABELS, DEFAULT_BULK_TAG_EDITOR_LABELS, type BulkReplaceLabels, type BulkTagEditorTestIds, type BulkReplaceDialogProps, type BulkReplaceDocRow, type BulkTagEditorDialogProps, type BulkTagEditorLabels, type BulkTagRow, } from './BulkTagEditor';

package/dist/files/views/FieldsEditorParts.d.ts

@@ -0,0 +1,151 @@
+import type { ComponentProps, ReactNode } from 'react';
+/** Every fixed string of the fields editor parts. Pass a partial `labels` to translate or reword. */
+export interface FieldsEditorLabels {
+    newItem: (singular: string) => string;
+    find: (singular: string) => string;
+    filter: (plural: string) => string;
+    clearFilter: string;
+    sort: (plural: string) => string;
+    sortNameAsc: string;
+    sortNameDesc: string;
+    sortNewest: string;
+    sortOldest: string;
+    select: string;
+    selectNamed: (name: string) => string;
+    selectNounNamed: (noun: string, name: string) => string;
+    selectsThisOnly: string;
+    renameNamed: (kind: string, name: string) => string;
+    rename: string;
+    nested: (count: number) => string;
+    hasInstruction: string;
+    collapse: (name: string) => string;
+    edit: (name: string) => string;
+    exportAria: string;
+}
+export declare const DEFAULT_FIELDS_EDITOR_LABELS: FieldsEditorLabels;
+export interface FieldsEditorToolbarTestIds {
+    newButton: string;
+    createForm: string;
+    filterInput: string;
+    filterClear: string;
+    sortSelect: string;
+}
+export interface FieldRowTestIds {
+    /** Replaces the whole `field-row-<tagId>` id. */
+    row: (tagId: string) => string;
+    /** Replaces the whole `tag-row-icon-<tagId>` id. */
+    icon: (tagId: string) => string;
+    /** Replaces the whole `label-rename-input-<tagId>` id. */
+    renameInput: (tagId: string) => string;
+    /** Replaces the whole `label-rename-<tagId>` id (the `-text` sibling follows it). */
+    rename: (tagId: string) => string;
+    /** Replaces the whole `apply-field-checkbox-<tagId>` id. */
+    checkbox: (tagId: string) => string;
+    /** Replaces the whole `field-nested-count-<tagId>` id. */
+    nestedCount: (tagId: string) => string;
+}
+export interface FieldsApplyBarTestIds {
+    apply: string;
+    clear: string;
+    delete: string;
+    export: string;
+}
+/** Fields editor column: a fixed toolbar, a scrolling list and a pinned apply bar. */
+export declare function FieldsEditorRoot({ testId, className, ...props }: ComponentProps<'div'> & {
+    /** Overrides the root test id (default `view-editor`). */
+    testId?: string;
+}): import("react").JSX.Element;
+/** The scrolling list region. */
+export declare function FieldsEditorList({ className, children, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export declare function FieldsEmptyState({ className, ...props }: ComponentProps<'div'>): import("react").JSX.Element;
+export type FieldsSortKey = 'name-asc' | 'name-desc' | 'created-desc' | 'created-asc';
+export interface FieldsEditorToolbarProps {
+    /** Singular / plural nouns used in copy and aria labels ("label", "labels"). */
+    nouns: {
+        singular: string;
+        plural: string;
+    };
+    /** Omit to hide the New button (read-only host). */
+    onNew?: () => void;
+    isCreating: boolean;
+    /** The create form stays mounted for the collapse animation; `open` drives the height. */
+    createForm?: {
+        mounted: boolean;
+        open: boolean;
+        children: ReactNode;
+    };
+    filterText: string;
+    onFilterTextChange: (value: string) => void;
+    sortBy: FieldsSortKey;
+    onSortByChange: (value: FieldsSortKey) => void;
+    className?: string;
+    labels?: Partial<FieldsEditorLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<FieldsEditorToolbarTestIds>;
+}
+/** New button (leads the list), inline create form, quick filter and sort. */
+export declare function FieldsEditorToolbar({ nouns, onNew, isCreating, createForm, filterText, onFilterTextChange, sortBy, onSortByChange, className, labels, testIds, }: FieldsEditorToolbarProps): import("react").JSX.Element;
+export interface FieldRenameState {
+    value: string;
+    onChange: (value: string) => void;
+    onCommit: () => void;
+    onCancel: () => void;
+}
+export interface FieldRowProps {
+    tagId: string;
+    name: string;
+    /** Label rows are a bare name; annotation (and untyped) rows expand into an edit form. */
+    kind?: 'label' | 'annotation';
+    /** API tag type (`text`, `checkbox`, ...): picks the glyph for non-label rows. */
+    tagType?: string | null;
+    /** Solid colour behind the glyph. */
+    iconColor: string;
+    /** Nesting depth (already clamped by the caller). Indents 20px per step. */
+    depth: number;
+    nestedCount?: number;
+    selected: boolean;
+    onSelectedChange: () => void;
+    usageLabel: string;
+    /** The shared/private toggle (app-owned). */
+    sharedToggle: ReactNode;
+    hasInstruction?: boolean;
+    /** Starts an in-place rename; omit when renaming is not allowed. */
+    onRename?: () => void;
+    renaming?: FieldRenameState | null;
+    /** Annotation rows: omit for a non-editable row. */
+    onToggleEditing?: () => void;
+    isEditing?: boolean;
+    /** Inline edit form, rendered under the row while `isEditing`. */
+    editForm?: ReactNode;
+    className?: string;
+    labels?: Partial<FieldsEditorLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<FieldRowTestIds>;
+}
+/** One field row: select box, glyph, name (rename in place), usage, share toggle, chevron. */
+export declare function FieldRow({ tagId, name, kind, tagType, iconColor, depth, nestedCount, selected, onSelectedChange, usageLabel, sharedToggle, hasInstruction, onRename, renaming, onToggleEditing, isEditing, editForm, className, labels, testIds, }: FieldRowProps): import("react").JSX.Element;
+export interface FieldsApplyBarProps {
+    /** Shown above the buttons, e.g. "Select documents in the table to apply these labels." */
+    hint?: ReactNode;
+    applyLabel: string;
+    applyTitle: string;
+    canApply: boolean;
+    onApply: () => void;
+    clearLabel: string;
+    clearTitle: string;
+    canClear: boolean;
+    onClear: () => void;
+    /** Omit to hide the delete button. */
+    onDelete?: () => void;
+    canDelete?: boolean;
+    deleteTitle?: string;
+    exportTitle: string;
+    canExport: boolean;
+    onExport: () => void;
+    className?: string;
+    labels?: Partial<FieldsEditorLabels>;
+    /** Overrides for the test ids (defaults keep the current ids). */
+    testIds?: Partial<FieldsApplyBarTestIds>;
+}
+/** Pinned bar: Add / Remove (to the target), delete checked, export checked. */
+export declare function FieldsApplyBar({ hint, applyLabel, applyTitle, canApply, onApply, clearLabel, clearTitle, canClear, onClear, onDelete, canDelete, deleteTitle, exportTitle, canExport, onExport, className, labels, testIds, }: FieldsApplyBarProps): import("react").JSX.Element;

package/dist/files/views/FieldsManagerParts.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentProps, ReactNode } from 'react';
+export interface FieldsManagerTitleProps extends Omit<ComponentProps<'div'>, 'title'> {
+    /** Heading text (default "Tags"). */
+    title?: ReactNode;
+}
+/** Panel heading: the tags glyph + "Tags". */
+export declare function FieldsManagerTitle({ title, className, ...props }: FieldsManagerTitleProps): import("react").JSX.Element;
+/** One-line definition of the active tab (labels vs annotations). */
+export declare function FieldsManagerDefinition({ testId, className, ...props }: ComponentProps<'p'> & {
+    /** Overrides the test id (default `fields-manager-definition`). */
+    testId?: string;
+}): import("react").JSX.Element;
+/** Region holding the fields editor; fills the remaining height. */
+export declare function FieldsManagerBody({ testId, className, ...props }: ComponentProps<'div'> & {
+    /** Overrides the test id (default `document-views`). */
+    testId?: string;
+}): import("react").JSX.Element;

package/dist/files/views/TagFormParts.d.ts

@@ -0,0 +1,109 @@
+import type { ReactNode, Ref } from 'react';
+/**
+ * Parts of the field (tag) create / edit form. The host owns the state and the submit rules and
+ * composes the parts it needs: a label field is name only, an annotation adds a value type, a
+ * select value adds options, a text value adds an AI instruction.
+ */
+export declare function TagFormRoot({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface TagFormFieldProps {
+    label: ReactNode;
+    /** Muted note under the control. */
+    hint?: ReactNode;
+    testId?: string;
+    children: ReactNode;
+}
+/** A labelled control of the form. */
+export declare function TagFormField({ label, hint, testId, children }: TagFormFieldProps): import("react").JSX.Element;
+export interface TagFormNameFieldProps {
+    label: string;
+    placeholder: string;
+    value: string;
+    onChange: (value: string) => void;
+    inputRef?: Ref<HTMLInputElement>;
+    testId?: string;
+}
+export declare function TagFormNameField({ label, placeholder, value, onChange, inputRef, testId, }: TagFormNameFieldProps): import("react").JSX.Element;
+export interface TagFormSelectOption {
+    value: string;
+    label: string;
+    isDisabled?: boolean;
+    testId?: string;
+}
+export interface TagFormSelectFieldProps {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    options: TagFormSelectOption[];
+    placeholder?: string;
+    /** Muted note under the select. */
+    hint?: ReactNode;
+    /** Note with a sparkle (AI) glyph under the select. */
+    aiNote?: string;
+    /** Id of the field wrapper. */
+    testId?: string;
+    trigger?: {
+        testId?: string;
+    };
+}
+/** A select field (value type, parent field). */
+export declare function TagFormSelectField({ label, value, onChange, options, placeholder, hint, aiNote, testId, trigger, }: TagFormSelectFieldProps): import("react").JSX.Element;
+/** Why the nesting picker is absent. */
+export declare function TagFormNote({ testId, children }: {
+    testId?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export interface TagFormOptionsEditorProps {
+    label: string;
+    options: string[];
+    draft: string;
+    onDraftChange: (value: string) => void;
+    onAdd: () => void;
+    onRemove: (index: number) => void;
+    addPlaceholder: string;
+    emptyHint: string;
+    removeLabel?: string;
+    addLabel?: string;
+}
+/** Options of a select value: the list with a remove button each, and an add input. */
+export declare function TagFormOptionsEditor({ label, options, draft, onDraftChange, onAdd, onRemove, addPlaceholder, emptyHint, removeLabel, addLabel, }: TagFormOptionsEditorProps): import("react").JSX.Element;
+export interface TagFormInstructionFieldProps {
+    label: string;
+    optionalLabel: string;
+    description: string;
+    placeholder: string;
+    value: string;
+    onChange: (value: string) => void;
+}
+/** The AI instruction of a text field. */
+export declare function TagFormInstructionField({ label, optionalLabel, description, placeholder, value, onChange, }: TagFormInstructionFieldProps): import("react").JSX.Element;
+export interface TagFormMetaLine {
+    /** "Created 3 days ago". */
+    text: string;
+    /** "by" word and the author's pill. */
+    byLabel?: string;
+    by?: ReactNode;
+}
+/** Created / Updated stamps of an existing field. */
+export declare function TagFormMeta({ lines }: {
+    lines: TagFormMetaLine[];
+}): import("react").JSX.Element;
+export interface TagFormFooterProps {
+    /** Create mode: the shared toggle + its label, at the start of the line. */
+    sharedToggle?: ReactNode;
+    onDelete?: () => void;
+    deleteLabel?: string;
+    onCancel: () => void;
+    cancelLabel?: string;
+    onSubmit: () => void;
+    submitLabel: string;
+    canSubmit: boolean;
+}
+/** "Shared with workspace": the host's visibility toggle with its label. */
+export declare function TagFormSharedToggle({ toggle, label }: {
+    toggle: ReactNode;
+    label: string;
+}): import("react").JSX.Element;
+/** Cancel / submit line, with the optional shared toggle and delete at the start. */
+export declare function TagFormFooter({ sharedToggle, onDelete, deleteLabel, onCancel, cancelLabel, onSubmit, submitLabel, canSubmit, }: TagFormFooterProps): import("react").JSX.Element;