@arbidocs/blocks 0.4.159 → 0.4.161

package/dist/connection/ConnectedSettings.d.ts

@@ -8,8 +8,9 @@
  * deletion, the password policy) is a prop.
  *
  * The hooks talk to the account client in scope (`useAccountClient` from `@arbidocs/react`):
- * `ConnectionProvider` provides one over the SDK; a host with its own session and API client
- * mounts its own `AccountClientProvider` (as ARBI-frontend does), and these sections work alike.
+ * `defaultHost`'s sign-in layer gives one over the SDK; a host with its own session and API
+ * client gives its own as its host config's `account` (as ARBI-frontend does), and these sections
+ * work alike.
  */
 import { type ReactNode } from 'react';
 import { type IdentityStatus } from '@arbidocs/react/ui';

package/dist/connection/ConnectionProvider.d.ts

@@ -50,8 +50,9 @@ export declare const workspaceStorageKey: (apiUrl: string, userKey: string) => s
 /** Shown on the sign-in screen after the session could not be recovered. */
 export declare const SESSION_EXPIRED_MESSAGE = "Your session expired. Sign in again.";
 /**
- * The connection, over the session state of the host (an `ArbiSessionStateProvider` above), else
- * its own: the selected workspace lives there, so every block reads one value.
+ * The sign-in layer of a blocks-only site, mounted by its host (`defaultHost`): login, demo mode
+ * and the selected workspace, over the host's session state (the selected workspace lives there,
+ * so every block reads one value). Its account client is the host's `account` below it.
  */
 export declare function ConnectionProvider({ config, children, }: {
     config: ArbiConnectionConfig;
@@ -80,8 +81,8 @@ export interface ConnectedWorkspace {
     }) => Promise<void>;
 }
 /**
- * The workspace for a connected kit: the `ConnectionProvider`'s when there is one, else the host's
- * own session (an app that mounts `ArbiProvider` and `ArbiSessionStateProvider` and keeps its
+ * The workspace for a connected kit: the sign-in layer's (`defaultHost`) when there is one, else the
+ * host's own session (an app whose host config has its `arbi` and `session` and keeps its
  * workspace open itself). So a kit runs the same in Clarum and in the ARBI app.
  */
 export declare function useConnectedWorkspace(): ConnectedWorkspace;

package/dist/connection/StreamedArtifact.d.ts

@@ -31,7 +31,7 @@ export interface StreamedArtifactProps extends Pick<UseStreamedArtifactOptions,
  *     with track changes) when its text is ready;
  *  4. an error with Retry when storing or parsing fails.
  *
- * Needs `<ArbiProvider>` + React Query. The host imports the editor stylesheet
+ * Needs an `<ArbiHost>` with an `arbi` + React Query. The host imports the editor stylesheet
  * (`@mdxeditor/editor/style.css`) and defines the global `Prism` in a module it imports at app
  * start (see the Artifacts section of docs/design/blocks-package.md).
  *

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

@@ -1,9 +1,9 @@
 /**
  * The billing kit: a host's projects (plan, usage, add-ons, invoices), the plan picker and checkout,
- * new projects, and the projects shared with the user. Stripe stays the host's
- * (`BillingSupportProvider`); without it projects show their limits and usage only.
+ * new projects, and the projects shared with the user. Stripe stays the host's (the host
+ * configuration's `billing`); without it projects show their limits and usage only.
  */
-export { BillingSupportProvider, useBillingSupport, type BillingSupport, type BillingCheckoutSupport, } from './support';
+export { useBillingSupport, type BillingSupport, type BillingCheckoutSupport } from './support';
 export { requestProjectBillingFocus, useProjectBillingFocus, type ProjectBillingFocus, } from './billing-focus';
 export { ProjectsTable } from './ProjectsTable';
 export { SharedProjects } from './SharedProjects';

package/dist/connection/billing/support.d.ts

@@ -1,9 +1,10 @@
 /**
  * What a host adds to the billing kit. Selling plans needs Stripe, which stays the host's: whether
- * this deployment sells plans (a publishable key is configured), and its embedded checkout. Without
- * a `BillingSupportProvider` nothing is for sale: projects show their limits and usage only.
+ * this deployment sells plans (a publishable key is configured), and its embedded checkout. It is the
+ * host configuration's `billing`; without it nothing is for sale: projects show their limits and
+ * usage only.
  */
-import { type ReactNode } from 'react';
+import type { ReactNode } from 'react';
 export interface BillingCheckoutSupport {
     /** Load the host's Stripe (lazily, when a checkout opens); `null` when it cannot. */
     load(): Promise<unknown> | null;
@@ -26,10 +27,6 @@ export interface BillingSupport {
         storage: number;
     }) => void;
 }
-export declare function BillingSupportProvider({ value, children, }: {
-    value: BillingSupport;
-    children: ReactNode;
-}): import("react").JSX.Element;
 export declare function useBillingSupport(): BillingSupport;
 /** The signed-in user's id (`usr-…`), to tell the projects they own from the others. */
 export declare function useSelfExtId(): string | undefined;

package/dist/connection/contacts/ConnectedAddContacts.d.ts

@@ -0,0 +1,9 @@
+export interface ConnectedAddContactsProps {
+    /** After a submit (also when nothing needed sending). */
+    onSuccess?: () => void;
+    onClose?: () => void;
+    initialEmail?: string;
+    /** Formatted referral reward ("£20"); omit to hide the banner. */
+    rewardAmount?: string;
+}
+export declare function ConnectedAddContacts({ onSuccess, onClose, initialEmail, rewardAmount, }: ConnectedAddContactsProps): import("react").JSX.Element;

package/dist/connection/contacts/ConnectedContactCardForm.d.ts

@@ -0,0 +1,11 @@
+import { type contacts } from '@arbidocs/sdk/browser';
+type Contact = contacts.Contact;
+export interface ConnectedContactCardFormProps {
+    /** The contact to edit; omitted or null for a new one. */
+    contact?: Contact | null;
+    onDone: () => void;
+    /** Open another contact (the one that already has an address this card uses). */
+    onOpenContact?: (contactId: string) => void;
+}
+export declare function ConnectedContactCardForm({ contact, onDone, onOpenContact, }: ConnectedContactCardFormProps): import("react").JSX.Element;
+export {};

package/dist/connection/contacts/ConnectedContactToggle.d.ts

@@ -0,0 +1,16 @@
+interface ToggleUser {
+    external_id: string;
+    email: string;
+    given_name: string;
+    family_name?: string | null;
+}
+export interface ConnectedContactToggleProps {
+    /** The person (a registered user) OR just an e-mail address (a pending invitation). */
+    user?: ToggleUser;
+    email?: string;
+    /** False when nested inside another tooltip. */
+    showTooltip?: boolean;
+    'data-testid'?: string;
+}
+export declare function ConnectedContactToggle({ user, email, showTooltip, 'data-testid': dataTestId, }: ConnectedContactToggleProps): import("react").JSX.Element | null;
+export {};

package/dist/connection/contacts/ConnectedContactsDirectory.d.ts

@@ -0,0 +1,10 @@
+export interface ConnectedContactsDirectoryProps {
+    className?: string;
+    /** Message a registered contact (by account id). Omitted: no message button. */
+    onMessage?: (userId: string) => void;
+    /** Invite people by e-mail (the empty state's second action). Omitted: not offered. */
+    onInviteByEmail?: () => void;
+    /** Show the plans, from the .vcf import's Pro notice. Omitted: no "See plans". */
+    onSeePlans?: () => void;
+}
+export declare function ConnectedContactsDirectory({ className, onMessage, onInviteByEmail, onSeePlans, }: ConnectedContactsDirectoryProps): import("react").JSX.Element;

package/dist/connection/contacts/ImportVcf.d.ts

@@ -0,0 +1,29 @@
+import { type contacts } from '@arbidocs/sdk/browser';
+type ContactImportResult = contacts.ContactImportResult;
+export type FileOutcome = {
+    file: string;
+    result: ContactImportResult;
+} | {
+    file: string;
+    error: string;
+};
+export type ImportState = {
+    kind: 'upgrade';
+} | {
+    kind: 'running';
+    done: FileOutcome[];
+    pending: number;
+} | {
+    kind: 'done';
+    done: FileOutcome[];
+};
+export declare function ImportVcfButton({ onState }: {
+    onState: (state: ImportState) => void;
+}): import("react").JSX.Element;
+export declare function ImportVcfSummary({ state, onClose, onSeePlans, }: {
+    state: ImportState;
+    onClose: () => void;
+    /** Show the plans (Pro). Omitted: no "See plans" button. */
+    onSeePlans?: () => void;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,5 @@
+export { ConnectedContactsDirectory, type ConnectedContactsDirectoryProps, } from './ConnectedContactsDirectory';
+export { ConnectedContactCardForm, type ConnectedContactCardFormProps, } from './ConnectedContactCardForm';
+export { ImportVcfButton, ImportVcfSummary, type ImportState, type FileOutcome } from './ImportVcf';
+export { ConnectedAddContacts, type ConnectedAddContactsProps } from './ConnectedAddContacts';
+export { ConnectedContactToggle, type ConnectedContactToggleProps } from './ConnectedContactToggle';

package/dist/connection/defaultHost.d.ts

@@ -0,0 +1,9 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { ArbiHostConfig } from '../provider/host';
+import type { ArbiConnectionConfig } from './types';
+export interface DefaultHostOptions {
+    /** The React Query client the kits share. Default: a new one. */
+    queryClient?: QueryClient;
+}
+/** `arbi` and the sign-in layer (`connection`) for `<ArbiHost config>`. Call it once per site. */
+export declare function defaultHost(config: ArbiConnectionConfig, { queryClient }?: DefaultHostOptions): Pick<ArbiHostConfig, 'arbi' | 'connection'>;

package/dist/connection/docx/ConnectedNativeDocxEditor.d.ts

@@ -3,14 +3,14 @@ export type ConnectedNativeDocxEditorProps = Omit<NativeDocxEditorProps, 'adapte
     fontBaseUrl?: string;
 };
 /**
- * The native Word editor on the signed-in ARBI session, under any host (a `ConnectionProvider`, or
- * the host's own `ArbiProvider` + session state). Until a live session has opened, a failure to
+ * The native Word editor on the signed-in ARBI session, under any host (`defaultHost`'s sign-in
+ * layer, or the host's own `arbi` and session state). Until a live session has opened, a failure to
  * open one falls back to the saved copy, read-only, so the document is still readable; later token
  * refreshes are not guarded (switching modes would drop unsaved edits).
  */
 export declare function ConnectedNativeDocxEditor({ fontBaseUrl, ...props }: ConnectedNativeDocxEditorProps): import("react").JSX.Element;
 /**
  * The native Word adapter on the signed-in session: the editor transport, the people to mention,
- * cross-references, the house template, and the host's extras (`NativeDocxSupportProvider`).
+ * cross-references, the house template, and the host's extras (its host config's `docx`).
  */
 export declare function useConnectedNativeDocxAdapter(fontBaseUrl?: string): NativeDocxAdapter;

package/dist/connection/docx/support.d.ts

@@ -1,10 +1,10 @@
 /**
  * What a host adds to the connected Word editor that the platform API alone cannot give: the
  * workspace's definitions (facts labelled "Definitions"), image generation (an assistant run), the
- * host's leave-page guard, and a comment to open the editor at. Every field is optional; without a
- * provider the editor simply offers less (no Defined term, no Generate image).
+ * host's leave-page guard, and a comment to open the editor at. It is the host configuration's
+ * `docx`; every field is optional, and without one the editor simply offers less (no Defined term,
+ * no Generate image).
  */
-import { type ReactNode } from 'react';
 import type { DefinitionSource } from '../../tags/definitions';
 import type { DocxImageGeneration } from '../../docx/layout/GenerateImage';
 export interface NativeDocxSupport {
@@ -14,14 +14,15 @@ export interface NativeDocxSupport {
     imageGeneration?: DocxImageGeneration;
     /** The open editor has (or no longer has) unsaved changes. */
     onDirtyChange?: (dirty: boolean) => void;
-    /** A comment thread to open when its document opens (a notification's link). */
-    commentTarget?: {
+    /** A comment thread to open when its document opens (a notification's link), as a hook. */
+    useCommentTarget?: () => {
         documentId: string;
         commentId: string;
     } | null;
 }
-export declare function NativeDocxSupportProvider({ value, children, }: {
-    value: NativeDocxSupport;
-    children: ReactNode;
-}): import("react").JSX.Element;
 export declare function useNativeDocxSupport(): NativeDocxSupport;
+/** The comment thread to open with its document (none without the host's). */
+export declare function useDocxCommentTarget(): {
+    documentId: string;
+    commentId: string;
+} | null;

package/dist/connection/files/bulk/ConnectedFilesBulkActions.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The floating bar of the selected documents: chat about them, fill AI fields, label, share or make
+ * private, move, export, produce, reprocess, keep offline, delete. Deleting, reprocessing and
+ * hiding from the members ask first. Moving, exporting and producing open the host's dialogs; the
+ * rest is written here. An action the host has no part for is left out.
+ */
+import { type WorkspaceDocument } from '@arbidocs/react';
+export interface ConnectedFilesBulkActionsProps<D extends WorkspaceDocument> {
+    selectedDocuments: D[];
+    onClearSelection: () => void;
+    /** The viewer may change documents here (members get the editing actions). */
+    isMember: boolean;
+    /** Review the selection one by one. Absent: not offered. */
+    onReview?: () => void;
+    /** Open the host's folder picker for the selection. */
+    onMoveToFolder: () => void;
+    /** Open the host's export dialog for the selection. */
+    onExport: () => void;
+    /** Open the host's production (Bates numbering) dialog. Absent: not offered. */
+    onProduce?: () => void;
+}
+export declare function ConnectedFilesBulkActions<D extends WorkspaceDocument>({ selectedDocuments, onClearSelection, isMember, onReview, onMoveToFolder, onExport, onProduce, }: ConnectedFilesBulkActionsProps<D>): import("react").JSX.Element;

package/dist/connection/files/bulk/useDocumentBulkActions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What the bulk bar does to the selected documents, written through `@arbidocs/react` and told
+ * through the environment: share or make private, delete, reprocess (under the settings in force
+ * now, at most 100 at a time). The selection is read fresh from the cache, so a document shared a
+ * moment ago counts as shared.
+ */
+import { type WorkspaceDocument } from '@arbidocs/react';
+/**
+ * The most documents one reprocess takes: it re-runs parsing and indexing on each, so a batch is
+ * capped to keep the workers' queues predictable.
+ */
+export declare const BULK_REPROCESS_LIMIT = 100;
+export declare function useDocumentBulkActions<D extends WorkspaceDocument>(selectedDocuments: D[]): {
+    freshSelectedDocuments: D[];
+    share: () => Promise<void>;
+    makePrivate: () => Promise<void>;
+    remove: () => Promise<void>;
+    reprocess: () => Promise<void>;
+};

package/dist/connection/files/explorer/FileTiles.d.ts

@@ -5,10 +5,9 @@
  * document pill, the mail handoff and the member / label lookups. `FileTile` is a draggable
  * document, `FolderTile` a droppable folder (separate components so the dnd hooks always run).
  */
-import { type WorkspaceDocument } from '@arbidocs/react';
+import { type DocumentHostActions, type DocumentStartItem, type WorkspaceDocument } from '@arbidocs/react';
 import { type ExplorerDensity, type ExplorerMenuItem } from '../../../files/ExplorerTile';
 import { type ExplorerFolder } from '../../../files/folders';
-import { type FilesStartItem } from '../support';
 export type { ExplorerDensity };
 /** A workspace member as a tile shows them (avatar and name). */
 export interface FileTileUser {
@@ -31,7 +30,7 @@ export declare function FileTooltipContent({ doc, modifiedBy, tagNameById, }: {
     tagNameById: ReadonlyMap<string, string>;
 }): import("react").JSX.Element;
 /** The "Start…" submenu: one entry per thing the host can start on the file or folder. */
-export declare function startMenuItem(items: readonly FilesStartItem[]): ExplorerMenuItem[];
+export declare function startMenuItem(items: readonly DocumentStartItem[]): ExplorerMenuItem[];
 interface FileTileProps {
     doc: FileTileDocument;
     density: ExplorerDensity;
@@ -61,6 +60,8 @@ interface FileTileProps {
     onDownload: (doc: FileTileDocument) => void;
     onMove?: (doc: FileTileDocument) => void;
     onDelete: (doc: FileTileDocument) => void;
+    /** The host's actions on documents (read once by the view). */
+    actions?: DocumentHostActions;
 }
 export declare const FileTile: import("react").NamedExoticComponent<FileTileProps>;
 interface FolderTileProps {
@@ -83,5 +84,7 @@ interface FolderTileProps {
     onDownload?: (folder: ExplorerFolder) => void;
     onMove?: (folder: ExplorerFolder) => void;
     onDelete?: (folder: ExplorerFolder) => void;
+    /** The host's actions on documents (read once by the view). */
+    actions?: DocumentHostActions;
 }
 export declare const FolderTile: import("react").NamedExoticComponent<FolderTileProps>;

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

@@ -0,0 +1,16 @@
+/**
+ * Edit the labels and annotations of several documents at once: tick or untick a label, set or
+ * clear a value, with each tag's mixed state shown and a confirmation before values are
+ * overwritten or removed. AI fields can be generated for the selection, choosing which existing
+ * values to replace first.
+ */
+import { type ReactNode } from 'react';
+import { type WorkspaceDocument } from '@arbidocs/react';
+export interface ConnectedBulkTagEditorProps {
+    selectedDocuments: WorkspaceDocument[];
+    open: boolean;
+    onClose: () => void;
+    /** Where this is (workspace / page), before the title. */
+    breadcrumb?: ReactNode;
+}
+export declare function ConnectedBulkTagEditor({ selectedDocuments, open, onClose, breadcrumb, }: ConnectedBulkTagEditorProps): import("react").JSX.Element;

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

@@ -0,0 +1,40 @@
+/**
+ * One group of the workspace's tags (labels, or annotations) as a list to manage: create, edit,
+ * rename and share them, find and sort them, tick some and put them on the target (documents, or
+ * the host's items such as the selected facts), take them off it, delete or export them.
+ */
+import { type ReactNode } from 'react';
+import { type TagGroup, type TagResponse } from '@arbidocs/sdk/browser';
+import { type AppliedAiFields, type FieldsTarget } from './useFieldsApply';
+/** The host's export of the checked tags to another workspace. */
+export type FieldsExportSlot = (props: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    items: {
+        extId: string;
+        label: string;
+    }[];
+}) => ReactNode;
+export interface ConnectedFieldsEditorProps {
+    /** The group listed (labels or annotations): the form and the wording follow it. */
+    group?: TagGroup;
+    /** The group's tags. */
+    tags: TagResponse[];
+    /** The documents Apply / Clear act on (without a `target`). */
+    documentIds?: string[];
+    /** The documents are the one under review: the wording says so. */
+    reviewing?: boolean;
+    /** Apply / Clear act on the host's items instead of documents. */
+    target?: FieldsTarget;
+    /** Opens the form for a new tag while above 0 (a counter, so each request opens it again). */
+    createRequest?: number;
+    /** The request was answered: the form was cancelled or a tag was created. */
+    onCreateRequestDone?: () => void;
+    /** A new annotation was created (e.g. show it as a column). */
+    onAnnotationCreated?: (tagId: string) => void;
+    /** AI fields were applied to documents (e.g. show their values). Absent: a message says so. */
+    onAiFieldsApplied?: (result: AppliedAiFields) => void;
+    /** Export the checked tags. Absent: not offered. */
+    renderExport?: FieldsExportSlot;
+}
+export declare function ConnectedFieldsEditor({ group: kind, tags, documentIds, reviewing, target, createRequest, onCreateRequestDone, onAnnotationCreated, onAiFieldsApplied, renderExport, }: ConnectedFieldsEditorProps): import("react").JSX.Element;

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

@@ -0,0 +1,33 @@
+/**
+ * The workspace's labels and annotations, in the two groups a user thinks in (the server keeps one
+ * tags table; every kind is on the Tags page):
+ *  - **Labels**: short names that file documents and facts (checkboxes).
+ *  - **Annotations**: per-document values (text, choice, number, date), optionally AI-filled, each
+ *    a Files table column.
+ * Each tab is a `ConnectedFieldsEditor` of its group. The host places it: inside its floating panel
+ * (with the panel's mode switcher), or as a dialog over another dialog.
+ */
+import { type ReactNode } from 'react';
+import { type TagGroup } from '@arbidocs/sdk/browser';
+import { type ConnectedFieldsEditorProps } from './ConnectedFieldsEditor';
+export interface ConnectedFieldsManagerProps extends Omit<ConnectedFieldsEditorProps, 'group' | 'tags'> {
+    /** The tab shown. */
+    kind: TagGroup;
+    onKindChange: (kind: TagGroup) => void;
+    /** Only the Labels tab, for items that carry no annotations (facts). */
+    labelsOnly?: boolean;
+    /**
+     * Whose labels are listed. A label used on documents and one used on facts are different
+     * vocabularies to the reader, so each side lists its own; a label used nowhere yet is in both
+     * (else it would vanish from the panel that just created it).
+     */
+    scope?: 'document' | 'fact';
+    /** In the host's floating panel: its mode switcher (and close), shown beside the tabs. */
+    modeSwitcher?: ReactNode;
+    /** As a dialog instead (e.g. over another dialog). */
+    dialog?: {
+        open: boolean;
+        onClose: () => void;
+    };
+}
+export declare function ConnectedFieldsManager({ kind, onKindChange, labelsOnly, scope, modeSwitcher, dialog, ...editorProps }: ConnectedFieldsManagerProps): import("react").JSX.Element;

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

@@ -0,0 +1,20 @@
+/**
+ * Create or edit a tag of any kind (the tag form without a Fields panel group): name, kind, format
+ * and options for an annotation, AI instruction, the tag it is nested under, sharing. The server's
+ * reason for refusing a change (a format change values already set would not fit) stays on screen
+ * with the form.
+ */
+import { type TagKind, type TagResponse } from '@arbidocs/sdk/browser';
+export interface ConnectedTagEditorDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The tag to edit; absent: a new tag. */
+    tag?: TagResponse;
+    /** The kind a new tag starts as. */
+    defaultKind?: TagKind;
+    /** The workspace's tags (the "Nested under" choices). */
+    tags: TagResponse[];
+    /** Called with the new tag's id and kind once created. */
+    onCreated?: (tagId: string, kind: TagKind) => void;
+}
+export declare function ConnectedTagEditorDialog({ open, onOpenChange, tag, defaultKind, tags, onCreated, }: ConnectedTagEditorDialogProps): import("react").JSX.Element;

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

@@ -0,0 +1,54 @@
+/**
+ * The form that creates or edits a tag: its name, kind, an annotation's value type and options, the
+ * AI instruction, the tag it is nested under, and (on create) whether it is shared. Used inline by
+ * the fields editor and in the tag editor dialog. It reports what was entered; the caller writes it.
+ */
+import { type TagGroup, type TagKind, type TagResponse } from '@arbidocs/sdk/browser';
+export type TagFormat = TagResponse['tag_type'];
+/** A new tag, as entered. */
+export interface TagCreateData {
+    name: string;
+    tag_type: TagFormat;
+    kind: TagKind;
+    shared: boolean;
+    instruction?: string | null;
+    /** The tag it is nested under, or null for the top level. */
+    parent_ext_id?: string | null;
+}
+/** A changed tag, as entered. */
+export interface TagUpdateData {
+    name: string;
+    tag_type?: TagFormat;
+    /** Present only when the kind changes. */
+    kind?: TagKind;
+    shared: boolean;
+    instruction?: string | null;
+    /** The tag it is nested under. Never null: see `canClearParent`. */
+    parent_ext_id?: string | null;
+}
+export interface ConnectedTagFormProps {
+    /** The tag to edit; absent: a new tag. */
+    tag?: TagResponse;
+    /**
+     * The workspace's other tags, for the "Nested under" picker. Absent: no picker (quick-create
+     * surfaces stay flat).
+     */
+    availableTags?: TagResponse[];
+    /** Called with a new tag. */
+    onSave?: (data: TagCreateData) => void;
+    /** Called with an edited tag. */
+    onUpdate?: (tagId: string, data: TagUpdateData) => void;
+    onCancel: () => void;
+    /** Focus the name on mount. */
+    autoFocus?: boolean;
+    /**
+     * Which group of the Fields panel this form creates or edits. `label`: a label (a checkbox, no AI
+     * instruction). `annotation`: picks among the value formats. Absent: the mixed form, every kind.
+     */
+    group?: TagGroup;
+    /** The kind a new tag starts as (without a group); default an annotation. */
+    defaultKind?: TagKind;
+    /** Name the tag after its kind ("Person Name") rather than as a document field ("Field Name"). */
+    nameByKind?: boolean;
+}
+export declare function ConnectedTagForm({ tag, availableTags, onSave, onUpdate, onCancel, autoFocus, group, defaultKind, nameByKind, }: ConnectedTagFormProps): import("react").JSX.Element;

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

@@ -0,0 +1,33 @@
+/**
+ * The parts of the review form's fields: the folder picker, the related documents, who last set a
+ * value, and the labels picker.
+ */
+import type { TagResponse } from '@arbidocs/sdk/browser';
+import { type RelatedDocs, type WorkspaceDocument } from '@arbidocs/react';
+type DocTag = NonNullable<WorkspaceDocument['doctags']>[number];
+/** The workspace's folders to move the document to. */
+export declare function FolderPicker({ documents, value, onSelect, }: {
+    documents: WorkspaceDocument[];
+    value: string | null | undefined;
+    onSelect: (folder: string | null) => void;
+}): import("react").JSX.Element;
+/** The related documents, the one open in the viewer marked. */
+export declare function RelatedDocuments({ doc, related, onOpen, onDelete, onCompare, }: {
+    doc: WorkspaceDocument;
+    related: RelatedDocs<WorkspaceDocument>;
+    onOpen?: (docId: string) => void;
+    onDelete?: (docId: string) => void;
+    onCompare?: (docId: string, otherDocId: string) => void;
+}): import("react").JSX.Element;
+/** Who last set a value, and when: shown on hover. */
+export declare function DocTagAttribution({ doctag }: {
+    doctag: DocTag;
+}): import("react").JSX.Element | null;
+/** The labels as a picker: toggle one, or create one by name and apply it. */
+export declare function LabelsCombobox({ labelTags, appliedTagIds, onToggle, onCreateAndApply, }: {
+    labelTags: TagResponse[];
+    appliedTagIds: ReadonlySet<string>;
+    onToggle: (tag: TagResponse) => void;
+    onCreateAndApply?: (name: string) => void;
+}): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+/**
+ * A person by a document or a field (who made a document, a field, a value): the host's own
+ * rendering when it has one (`DocumentsSupport.renderUser`: presence, their card), else the kit's
+ * avatar, which opens them when the host can.
+ */
+import { type DocumentPerson } from '@arbidocs/react';
+export declare function DocumentUser({ user, tooltip, }: {
+    user: DocumentPerson | undefined;
+    /** Whether hovering shows their card (the host's rendering). */
+    tooltip?: boolean;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,48 @@
+/**
+ * One field of a document as the review form shows it (a column of the documents table, one per
+ * row): its label, icon and the value, editable where the table's column is. Standard fields,
+ * metadata, the folder, related documents, the labels and each annotation (with who last set it).
+ */
+import type { ElementType, ReactNode } from 'react';
+import { type TagResponse } from '@arbidocs/sdk/browser';
+import type { DocumentPerson, RelatedDocs, WorkspaceDocument } from '@arbidocs/react';
+type DocTag = NonNullable<WorkspaceDocument['doctags']>[number];
+export type DocTagCitations = NonNullable<DocTag['citations']> | null;
+/** A field as the form lays it out. */
+export interface DocumentFieldContent {
+    label: string;
+    icon?: ReactNode;
+    /** The annotation the field is (its pill is shown as the label). */
+    tag?: TagResponse;
+    children: ReactNode;
+}
+export interface DocumentFieldOptions {
+    /** The column (a standard field's id, or an annotation's tag id). */
+    columnId: string;
+    doc: WorkspaceDocument;
+    canEdit: boolean;
+    workspaceTags: TagResponse[];
+    /** The workspace's documents (the folders to pick from). */
+    allDocuments?: WorkspaceDocument[];
+    /** Who uploaded the document. */
+    creator?: DocumentPerson;
+    getColumnLabel: (colId: string) => string;
+    getColumnIcon: (colId: string) => ElementType | undefined;
+    isColumnEditable: (colId: string) => boolean;
+    onUpdateDocumentField: (field: string, value: unknown) => void;
+    onUpdateTagValue: (tag: TagResponse, value: string | boolean) => void;
+    onUpdateTagWithCitations: (tag: TagResponse, note: string, citations: DocTagCitations) => void;
+    /** Create a label and apply it (the labels picker). Absent: the picker only toggles. */
+    onCreateAndApplyLabel?: (name: string) => void;
+    /** The document's related documents (email family, copies, duplicates, similar). */
+    relatedDocs?: RelatedDocs<WorkspaceDocument>;
+    /** Open a related document. */
+    onOpenDocument?: (docId: string) => void;
+    /** Delete a related document (asks first). */
+    onDeleteDocument?: (docId: string) => void;
+    /** Compare with a similar document. Absent: not offered. */
+    onCompareDocuments?: (docId: string, otherDocId: string) => void;
+}
+/** The field of `columnId`, or null when the document has none to show there. */
+export declare function documentFieldContent(options: DocumentFieldOptions): DocumentFieldContent | null;
+export {};

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

@@ -0,0 +1,20 @@
+/**
+ * The fields editor's writes on the tags themselves: create, edit, rename, share, and delete the
+ * checked ones after one confirmation. Each says how it went.
+ */
+import { type TagResponse } from '@arbidocs/sdk/browser';
+import type { TagCreateData, TagUpdateData } from './ConnectedTagForm';
+export declare function useFieldWrites({ tags, nouns, }: {
+    /** The tags the editor lists. */
+    tags: TagResponse[];
+    nouns: {
+        singular: string;
+        plural: string;
+    };
+}): {
+    create: (data: TagCreateData) => Promise<string | null>;
+    update: (tagId: string, data: TagUpdateData) => void;
+    rename: (tag: TagResponse, name: string) => Promise<void>;
+    toggleShared: (tag: TagResponse) => Promise<void>;
+    removeMany: (tagIds: string[]) => Promise<void>;
+};