@arbidocs/blocks 0.4.147 → 0.4.150

package/dist/connection/facts/useFactSelection.d.ts

@@ -0,0 +1,82 @@
+import { type RefObject } from 'react';
+import type { GridApi } from 'ag-grid-community';
+import type { Fact, FactsChat, FactsLabelTarget } from './types';
+export declare function useFactSelection(notes: Fact[], gridApiRef: RefObject<GridApi<Fact> | null>, setFactTags: (fact: Fact, tagExtIds: string[]) => Promise<void>, chat: FactsChat | undefined): {
+    selectedFacts: {
+        text: string;
+        citations?: import("@arbidocs/client").components["schemas"]["CitationSources"] | null;
+        external_id: string;
+        workspace_ext_id: string;
+        shared: boolean;
+        confirmed: boolean;
+        date_start?: string | null;
+        date_end?: string | null;
+        timezone?: string | null;
+        reminder_task_ext_ids: string[];
+        tags: import("@arbidocs/client").components["schemas"]["FactTagResponse"][];
+        created_by_ext_id: string;
+        created_at: string;
+        updated_at: string;
+    }[];
+    clearSelection: () => void;
+    gridSelection: {
+        mode: "multiple";
+        selected: {
+            text: string;
+            citations?: import("@arbidocs/client").components["schemas"]["CitationSources"] | null;
+            external_id: string;
+            workspace_ext_id: string;
+            shared: boolean;
+            confirmed: boolean;
+            date_start?: string | null;
+            date_end?: string | null;
+            timezone?: string | null;
+            reminder_task_ext_ids: string[];
+            tags: import("@arbidocs/client").components["schemas"]["FactTagResponse"][];
+            created_by_ext_id: string;
+            created_at: string;
+            updated_at: string;
+        }[];
+        onSelectionChange: import("react").Dispatch<import("react").SetStateAction<{
+            text: string;
+            citations?: import("@arbidocs/client").components["schemas"]["CitationSources"] | null;
+            external_id: string;
+            workspace_ext_id: string;
+            shared: boolean;
+            confirmed: boolean;
+            date_start?: string | null;
+            date_end?: string | null;
+            timezone?: string | null;
+            reminder_task_ext_ids: string[];
+            tags: import("@arbidocs/client").components["schemas"]["FactTagResponse"][];
+            created_by_ext_id: string;
+            created_at: string;
+            updated_at: string;
+        }[]>>;
+    };
+    bulkDelete: () => Promise<void>;
+    freshSelectedFacts: {
+        text: string;
+        citations?: import("@arbidocs/client").components["schemas"]["CitationSources"] | null;
+        external_id: string;
+        workspace_ext_id: string;
+        shared: boolean;
+        confirmed: boolean;
+        date_start?: string | null;
+        date_end?: string | null;
+        timezone?: string | null;
+        reminder_task_ext_ids: string[];
+        tags: import("@arbidocs/client").components["schemas"]["FactTagResponse"][];
+        created_by_ext_id: string;
+        created_at: string;
+        updated_at: string;
+    }[];
+    factsLabelTarget: FactsLabelTarget;
+    allSelectedInChat: boolean;
+    bulkToggleInChat: () => void;
+    bulkSetShared: (shouldShare: boolean) => Promise<void>;
+    exportItems: {
+        extId: string;
+        label: string;
+    }[];
+};

package/dist/connection/facts/useFactsGrid.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Wiring for the facts AG Grid: stable columns and grid options (context delegates through a ref
+ * so the grid never blanket-refreshes), label cell, focus-flash from quick-access jumps.
+ */
+import type { useCreateTag } from '@arbidocs/react';
+import type { TagResponse } from '@arbidocs/sdk/browser';
+import { type ReactNode, type RefObject } from 'react';
+import type { GridApi } from 'ag-grid-community';
+import { type FactCreator, type LookupUser } from './factPageColumns';
+import type { Fact } from './types';
+type Tag = TagResponse;
+/** Who may do something to a fact, by its creator's id. */
+type CreatorCheck = (creatorExtId: string | null | undefined) => boolean;
+interface FactsGridArgs {
+    notes: Fact[];
+    labelTags: Tag[];
+    createTagStable: Pick<ReturnType<typeof useCreateTag>, 'mutateAsync'>;
+    setFactTags: (fact: Fact, tagExtIds: string[]) => Promise<void>;
+    /** The current chat's fact ids: the In chat column refreshes when they change. */
+    chatFactIds: string[];
+    toggleInChat: (fact: Fact) => void;
+    toggleConfirmed: (fact: Fact) => void;
+    toggleShared: (fact: Fact) => void;
+    remove: (fact: Fact) => Promise<boolean>;
+    openEdit: (fact: Fact) => void;
+    gridApiRef: RefObject<GridApi<Fact> | null>;
+    editingIdRef: RefObject<string | null>;
+    /** Who may change who sees a fact, and who may reword or delete it. */
+    canChangeSharing: CreatorCheck;
+    canRewrite: CreatorCheck;
+    lookupUser: LookupUser;
+    renderUser?: (user: FactCreator | null) => ReactNode;
+    /** A fact to bring into view once (a jump from elsewhere), and its done. */
+    focusFactId?: string | null;
+    onFocused?: () => void;
+    /** The chat's In chat column (absent: no chat). */
+    hasChat: boolean;
+}
+export declare function useFactsGrid({ notes, labelTags, createTagStable, setFactTags, chatFactIds, toggleInChat, toggleConfirmed, toggleShared, remove, openEdit, gridApiRef, editingIdRef, canChangeSharing: canChange, canRewrite, lookupUser, renderUser, focusFactId: focusedFactId, onFocused, hasChat, }: FactsGridArgs): {
+    factColumns: import("ag-grid-community").ColDef<{
+        text: string;
+        citations?: import("@arbidocs/client").components["schemas"]["CitationSources"] | null;
+        external_id: string;
+        workspace_ext_id: string;
+        shared: boolean;
+        confirmed: boolean;
+        date_start?: string | null;
+        date_end?: string | null;
+        timezone?: string | null;
+        reminder_task_ext_ids: string[];
+        tags: import("@arbidocs/client").components["schemas"]["FactTagResponse"][];
+        created_by_ext_id: string;
+        created_at: string;
+        updated_at: string;
+    }, any>[];
+    factGridOptions: {
+        context: {
+            lookupUser: LookupUser;
+            renderUser: ((user: FactCreator | null) => ReactNode) | undefined;
+            renderFactTags: (fact: Fact, rowHeight?: number) => import("react").JSX.Element;
+            openEdit: (m: Fact) => void;
+            removeFact: (m: Fact) => Promise<boolean>;
+            canChangeSharing: (m: Fact) => boolean;
+            canRewrite: (m: Fact) => boolean;
+        };
+        onRowDoubleClicked: (e: {
+            data?: Fact;
+        }) => void | undefined;
+        getRowClass: (p: {
+            data?: Fact;
+        }) => "facts-row-editing" | undefined;
+        suppressClickEdit: boolean;
+        tooltipInteraction: boolean;
+    };
+    factCtxRef: RefObject<{
+        lookupUser: LookupUser;
+        renderUser: ((user: FactCreator | null) => ReactNode) | undefined;
+        renderFactTags: (fact: Fact, rowHeight?: number) => import("react").JSX.Element;
+        openEdit: (fact: Fact) => void;
+        removeFact: (fact: Fact) => Promise<boolean>;
+        canChange: CreatorCheck;
+        canRewrite: CreatorCheck;
+        chatFactIdSet: Set<string>;
+        toggleInChat: (fact: Fact) => void;
+    }>;
+};
+export {};

package/dist/connection/facts/useFactsPageView.d.ts

@@ -0,0 +1,4 @@
+import type { FactsPageView } from './types';
+/** The timeline's label gutter, by default. */
+export declare const DEFAULT_TIMELINE_LABEL_WIDTH = 240;
+export declare function useFactsPageView(): FactsPageView;

package/dist/connection/mail/ConnectedMailComposer.d.ts

@@ -7,7 +7,7 @@
  */
 import { type RefObject } from 'react';
 import { type MailAccount, type MailCompose, type MailMessage } from '@arbidocs/react';
-import type { MailDocumentSource, MailOfflineSupport, MailWordEditor } from './types';
+import type { MailDocumentSource, MailOfflineSupport, MailRecipientSuggestions, MailWordEditor } from './types';
 export interface ConnectedMailComposerProps {
     /** Open this saved draft (from the account's Drafts) instead of a new message. */
     draftId?: string;
@@ -35,6 +35,8 @@ export interface ConnectedMailComposerProps {
     offline?: MailOfflineSupport;
     /** Workspace documents to attach ("From workspace"). Absent: not offered. */
     documents?: MailDocumentSource;
+    /** People suggested while typing a recipient. Absent: plain address fields. */
+    recipients?: MailRecipientSuggestions;
     /** A native draft's body in the Word editor (see {@link MailWordEditor}). Absent: the rich-text body. */
     word?: MailWordEditor;
     /** This compose session, stable across remounts (its Word room is kept for it). */

package/dist/connection/mail/ConnectedMailbox.d.ts

@@ -12,7 +12,7 @@ import { type ReactNode } from 'react';
 import type { GridState } from 'ag-grid-community';
 import { type MailAddress, type MailAccount, type MailAttachment, type MailMessage } from '@arbidocs/react';
 import { type MailAliasUser } from './ConnectedMailAccounts';
-import type { MailDocumentSource, MailOfflineSupport, MailPanelProps, MailSaveToWorkspace, MailWordEditor } from './types';
+import type { MailDocumentSource, MailRecipientSuggestions, MailOfflineSupport, MailPanelProps, MailSaveToWorkspace, MailWordEditor } from './types';
 export interface ConnectedMailboxProps {
     /** Which mailbox: an account id, or `'native'` for the user's own inbox. Default: the first. */
     mailbox?: string;
@@ -42,6 +42,8 @@ export interface ConnectedMailboxProps {
     offline?: MailOfflineSupport;
     /** The open workspace's documents, attachable in the composer. */
     documents?: MailDocumentSource;
+    /** People suggested while typing a recipient in the composer. Absent: plain address fields. */
+    recipients?: MailRecipientSuggestions;
     /** Saving an email into a workspace ("Save to workspace" on native mail). */
     saveToWorkspace?: MailSaveToWorkspace;
     /** Native drafts' bodies in the Word editor, where ARBI's edits are suggestions. Absent: rich text. */
@@ -65,4 +67,4 @@ export interface ConnectedMailboxProps {
     /** The message opened first (e.g. restored after a redirect). */
     initialMessageId?: string | null;
 }
-export declare function ConnectedMailbox({ mailbox, draftId, onDraftOpened, folder: requestedFolder, onFolderOpened, composeAttachments, onComposeOpened, onOpenDocument, user, productName, oauthReturnPath, personLabel, offline, documents, saveToWorkspace, word, onReplyWithArbi, renderInvite, renderPanel, onViewerOpenChange, gridState, onGridStateChange, initialMessageId, }: ConnectedMailboxProps): import("react").JSX.Element;
+export declare function ConnectedMailbox({ mailbox, draftId, onDraftOpened, folder: requestedFolder, onFolderOpened, composeAttachments, onComposeOpened, onOpenDocument, user, productName, oauthReturnPath, personLabel, offline, documents, recipients, saveToWorkspace, word, onReplyWithArbi, renderInvite, renderPanel, onViewerOpenChange, gridState, onGridStateChange, initialMessageId, }: ConnectedMailboxProps): import("react").JSX.Element;

package/dist/connection/mail/MailComposerForm.d.ts

@@ -1,6 +1,6 @@
 import { type RefObject } from 'react';
 import { type MailAccount, type MailCompose, type MailMessage } from '@arbidocs/react';
-import type { MailDocumentSource, MailOfflineSupport, MailWordEditor } from './types';
+import type { MailDocumentSource, MailOfflineSupport, MailRecipientSuggestions, MailWordEditor } from './types';
 export interface MailComposerFormProps {
     account?: MailAccount;
     initial: MailCompose;
@@ -21,6 +21,8 @@ export interface MailComposerFormProps {
     localDraftId?: string;
     offline?: MailOfflineSupport;
     documents?: MailDocumentSource;
+    /** People suggested while typing a recipient. Absent: plain address fields. */
+    recipients?: MailRecipientSuggestions;
     /** A native draft's body in the Word editor. Absent: the rich-text body. */
     word?: MailWordEditor;
     /** This compose session, stable across remounts (its Word room is kept for it). */
@@ -31,4 +33,4 @@ export interface MailComposerFormProps {
     headerSlot?: HTMLElement | null;
 }
 /** Write, save and send one message. */
-export declare function MailComposerForm({ account, initial, maxBytes, ready, drafts, onClose, onOpenDraft, onReload, onChange, embedded, closeRequestRef, localDraftId: initialLocalDraftId, offline, documents, word, sessionKey, roomId, headerSlot, }: MailComposerFormProps): import("react").JSX.Element;
+export declare function MailComposerForm({ account, initial, maxBytes, ready, drafts, onClose, onOpenDraft, onReload, onChange, embedded, closeRequestRef, localDraftId: initialLocalDraftId, offline, documents, recipients, word, sessionKey, roomId, headerSlot, }: MailComposerFormProps): import("react").JSX.Element;

package/dist/connection/mail/MailRecipientInput.d.ts

@@ -0,0 +1,14 @@
+import { type InputHTMLAttributes } from 'react';
+import type { MailRecipientSuggestions } from './types';
+type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'onChange'>;
+export interface MailRecipientInputProps extends InputProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    suggestions: MailRecipientSuggestions;
+}
+/**
+ * A To / Cc / Bcc field that suggests people as you type the current address (a combobox: arrows move,
+ * Enter picks, Escape dismisses). Picking replaces the address being typed and leaves room for the next one.
+ */
+export declare function MailRecipientInput({ value, onValueChange, suggestions: source, className, ...input }: MailRecipientInputProps): import("react").JSX.Element;
+export {};

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

@@ -4,4 +4,4 @@ export { ConnectedMailMessage, type ConnectedMailMessageProps } from './Connecte
 export { resolveMailbox } from './mailbox';
 export { ConnectedMailAccounts, type ConnectedMailAccountsProps, type MailAliasUser, } from './ConnectedMailAccounts';
 export { ConnectedMailSetup } from './ConnectedMailSetup';
-export type { MailLocalDraft, MailOutboxEntry, MailOutboxRequest, MailOfflineSupport, MailDocumentSource, MailSaveToWorkspace, MailPanelProps, MailWordEditor, } from './types';
+export type { MailLocalDraft, MailOutboxEntry, MailOutboxRequest, MailOfflineSupport, MailDocumentSource, MailRecipientSuggestions, MailSaveToWorkspace, MailPanelProps, MailWordEditor, } from './types';

package/dist/connection/mail/types.d.ts

@@ -59,6 +59,16 @@ export interface MailOfflineSupport {
     /** The request never got an answer (no connection), as opposed to the server refusing it. */
     isNetworkFailure(error: unknown): boolean;
 }
+/**
+ * People to suggest while an address is typed in To / Cc / Bcc. `useSuggestions` is a hook (called on every
+ * render with the address being typed, '' for none): pass a stable object (e.g. a module constant).
+ */
+export interface MailRecipientSuggestions {
+    useSuggestions(query: string): {
+        email: string;
+        name?: string | null;
+    }[];
+}
 /** The open workspace's documents, attachable to an email as their files. */
 export interface MailDocumentSource {
     documents: MailAttachableDocument[];

package/dist/connection/search/ConnectedSearchPage.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The Smart Search page, connected: search the open workspace's documents for passages
+ * (`useSemanticSearch` over the shared search session, so results outlive the page), group them
+ * by document or list them by relevance, cut them by a relevance threshold, open a passage in the
+ * host's viewer (`BlocksEnvironment.openDocument`), and label every listed document.
+ *
+ * Runs under any host (`useConnectedWorkspace`). What it searches is the host's to narrow: pass
+ * `scope` (the filtered documents and the filter control); without it the page searches the whole
+ * workspace. A host can also bring its own document chip and empty-workspace surface.
+ */
+import { type ReactNode } from 'react';
+import { type ConnectedDocument } from '../workspaceData';
+import { type SearchRowLabels } from './SearchResultRows';
+/** What the page searches: the host's narrowed document set and the control that narrows it. */
+export interface SearchScope {
+    /** The documents to search; `null` searches the whole workspace (nothing narrowed). */
+    docIds: string[] | null;
+    /** How many documents are in scope (the tab's count, the intro's "N documents"). */
+    count: number;
+    /** The filter control, shown in the tab's actions on the standalone page. */
+    filter?: ReactNode;
+    /** Hover handlers of the filter control, attached to the whole tab. */
+    filterHoverHandlers?: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+}
+export interface SearchDocumentChipProps {
+    docId: string;
+    /** The document from the open workspace's list, when it is there. */
+    doc?: ConnectedDocument;
+}
+export interface ConnectedSearchPageLabels extends SearchRowLabels {
+    tab: string;
+    /** An example query rather than an instruction: quoted phrase plus free words. */
+    placeholder: string;
+    byDoc: string;
+    byDocTitle: string;
+    byPassage: string;
+    byPassageTitle: string;
+    grouping: string;
+    offline: string;
+    tooManyDocuments: (count: number, max: number) => string;
+    /** The default name of the label made from a search. */
+    labelName: (query: string) => string;
+    labelled: (count: number, name: string) => string;
+    labelFailed: string;
+}
+export declare const DEFAULT_CONNECTED_SEARCH_PAGE_LABELS: ConnectedSearchPageLabels;
+export interface ConnectedSearchPageProps {
+    /**
+     * Shown inside a host's Files view: no tab header of its own (the host has it and the filter),
+     * and the grouping toggle on a slim row above the search box.
+     */
+    embedded?: boolean;
+    /** What to search; default the whole workspace. */
+    scope?: SearchScope;
+    /** A document's chip in a group's header; default the document's entity pill. */
+    DocumentChip?: (props: SearchDocumentChipProps) => ReactNode;
+    /** Shown instead of the intro when the workspace has no documents (e.g. an upload surface). */
+    emptyWorkspace?: ReactNode;
+    labels?: Partial<ConnectedSearchPageLabels>;
+}
+export declare function ConnectedSearchPage({ embedded, scope, DocumentChip, emptyWorkspace, labels, }: ConnectedSearchPageProps): import("react").JSX.Element;

package/dist/connection/search/SearchResultRows.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The search page's rows: a passage in the flat list, a passage inside its document's group, and
+ * the group's header. Each is memoized against stable props from the page, so paging or moving
+ * the threshold doesn't re-render rows.
+ */
+import { type MouseEvent, type ReactNode } from 'react';
+import { type SearchChunk } from '@arbidocs/react';
+import { type SearchDocumentGroup } from '../../retrieval/search-results';
+export interface SearchRowLabels {
+    /** Badge on a passage that contains none of the query's words. */
+    meaningMatch: string;
+    meaningMatchTitle: string;
+    /** The page a grouped passage is on. */
+    page: (page: number) => string;
+    /** A grouped passage without a page. */
+    passage: string;
+}
+export declare const DEFAULT_SEARCH_ROW_LABELS: SearchRowLabels;
+interface RowProps {
+    hit: SearchChunk;
+    terms: string[];
+    onOpen: (e: MouseEvent, hit: SearchChunk) => void;
+    labels: SearchRowLabels;
+}
+export declare const FlatResultRow: import("react").NamedExoticComponent<RowProps & {
+    position: number;
+}>;
+export declare const GroupedResultRow: import("react").NamedExoticComponent<RowProps & {
+    testId: string;
+}>;
+export declare const SearchGroupRowHeader: import("react").NamedExoticComponent<{
+    group: SearchDocumentGroup;
+    /** The document's chip. */
+    source: ReactNode;
+    isExpanded: boolean;
+    onToggle: (docId: string) => void;
+}>;
+export {};

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

@@ -0,0 +1,2 @@
+export { ConnectedSearchPage, DEFAULT_CONNECTED_SEARCH_PAGE_LABELS, type ConnectedSearchPageProps, type ConnectedSearchPageLabels, type SearchScope, type SearchDocumentChipProps, } from './ConnectedSearchPage';
+export { DEFAULT_SEARCH_ROW_LABELS, type SearchRowLabels } from './SearchResultRows';

package/dist/connection/tags/ConnectedTagTable.d.ts

@@ -0,0 +1,108 @@
+/**
+ * `TagTable` bound to the connection: every tag of a kind in the open workspace (`kind="issue"`:
+ * every issue), or with `parentId` a label's children. The columns are the kind's fields in the
+ * workspace (`useTagKindSchema`), edited in place and saved as the kind's schema
+ * (`useUpdateTagKindSchema`); the rows are the tag list filtered by kind with links (`useTags`),
+ * their cells saved with `useSetTagValues`. "Add row" creates a tag of the kind (issues, people and
+ * organisations are flat: no parent). The workspace's people fill person columns and its tags
+ * link columns; the snapshot is filed in the workspace as a Word document (`.docx`, so it opens in
+ * the Word editor; its id goes to `onExported`, so a host can open it or send it for signature) or
+ * downloaded. A `filter` narrows the rows to the tagged items it lets through and to the tags
+ * whose name (or values) match its text, as the Tags page's filter does. A refused write is said
+ * through the blocks environment (`notify`).
+ */
+import { type TagKind } from '@arbidocs/sdk/browser';
+import { type TagTableProps } from '../../tags/TagTable';
+import { type TagFilterMatches } from './tagCombine';
+/** What the filter box searches: tag names, and optionally their field values. */
+export type TagTableFilterField = 'name' | 'values';
+/** What narrows a table: the tagged items a tag filter lets through, and the filter box's text. */
+export interface TagTableFilter {
+    matches?: TagFilterMatches;
+    text?: string;
+    fields?: readonly TagTableFilterField[];
+}
+/**
+ * What a tag's values can name: the open workspace's people (person fields) and tags (link fields,
+ * e.g. a person's organisation, named for their chips), and the tag list itself.
+ */
+export declare function useTagValueOptions(): {
+    allTags: {
+        external_id: string;
+        workspace_ext_id: string;
+        name: string;
+        instruction?: string | null | undefined;
+        tag_type: {
+            type: "checkbox" | "text" | "number" | "select" | "search" | "date";
+            options: string[];
+        };
+        kind: "label" | "annotation" | "search" | "issue" | "person" | "organisation";
+        shared: boolean;
+        parent_ext_id?: string | null | undefined;
+        doctag_count: number;
+        facttag_count: number;
+        convotag_count: number;
+        field_values?: {
+            [x: string]: unknown;
+        } | undefined;
+        links?: {
+            docs?: {
+                doc_ext_id: string;
+                file_name: string;
+                note?: string | null | undefined;
+                citations_count: number;
+                updated_at: string;
+            }[] | undefined;
+            facts?: {
+                fact_ext_id: string;
+                text: string;
+                confirmed: boolean;
+                updated_at: string;
+            }[] | undefined;
+            threads?: {
+                conversation_ext_id: string;
+                title?: string | null | undefined;
+                updated_at: string;
+            }[] | undefined;
+            doc_count: number;
+            fact_count: number;
+            thread_count: number;
+        } | null | undefined;
+        created_by_ext_id: string;
+        updated_by_ext_id?: string | null | undefined;
+        created_at: string;
+        updated_at: string;
+    }[];
+    people: {
+        value: string;
+        label: string;
+    }[];
+    tagOptions: {
+        value: string;
+        label: string;
+        kind: "label" | "search" | "annotation" | "person" | "organisation" | "issue";
+    }[];
+};
+export interface ConnectedTagTableProps extends Pick<TagTableProps, 'onOpenDocument' | 'onOpenFact' | 'onOpenThread' | 'onOpenRow' | 'onOpenTag' | 'actions' | 'labels' | 'className' | 'testId'> {
+    /** The rows are the workspace's tags of this kind, oldest first; the columns its fields. */
+    kind: TagKind;
+    /** This tag's children instead (a label hierarchy; flat kinds have none), as rows of `kind`. */
+    parentId?: string;
+    /** How many documents, facts and threads each row lists (the rest are counted). Default 3. */
+    linksLimit?: number;
+    /** Narrow the rows (see {@link TagTableFilter}). */
+    filter?: TagTableFilter;
+    /** The exported document's title; default the kind's ("Issues", "People", …). */
+    exportTitle?: string;
+    /** The snapshot was filed: its document id. Absent: no export button. */
+    onExported?: (documentId: string) => void;
+    /** Offer the snapshot as a `.docx` download. Default true. */
+    downloadable?: boolean;
+    /** Offer "Add row" (where the kind is added by name). Default true. */
+    addRows?: boolean;
+    /** Edit the columns (the kind's fields). Default true. */
+    editColumns?: boolean;
+    /** Read only: no cell edits, no "Add row", no column changes. */
+    readOnly?: boolean;
+}
+export declare function ConnectedTagTable({ kind, parentId, linksLimit, filter, exportTitle, onExported, downloadable, addRows, editColumns, readOnly, ...props }: ConnectedTagTableProps): import("react").JSX.Element;

package/dist/connection/tags/ConnectedTagsPage.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The Tags page: every tag of the open workspace, by kind — labels, annotations, issues, people,
+ * organisations and saved searches — and everything tagged with each one.
+ *
+ * The tab header has a button per kind and the filter box with its filter menu, which only filters
+ * what is shown: tags included or excluded, whichever kind they are, narrow every view to the
+ * items they let through (`TagFilterChips` lists them). In the main area a search-and-create picker
+ * (`TagPicker`) opens a tag of the open kind or creates one. A kind shows all its tags as a table
+ * (their kind's fields as columns, and the items tagged with each); a tag shows its fields,
+ * editable in place, and every document (with the tag's note there and the passages it cites),
+ * fact and thread tagged with it, plus its sub-tags. Tags are moved, shared and deleted here;
+ * people and organisations can be extracted from documents.
+ *
+ * Data comes from `@arbidocs/react` (the open workspace's tags, tables, kinds, facts) and the
+ * connected workspace lists (`useConnectedDocuments`, `useConnectedConversations`: a host that keeps
+ * them itself gives them once through `ConnectedWorkspaceDataProvider`). What belongs to other
+ * parts of the host — the AI review, Smart Search, the tag editor form, opening a fact — comes in
+ * as callbacks and a render slot.
+ */
+import { type ReactNode } from 'react';
+import { type TagKind, type TagResponse } from '@arbidocs/sdk/browser';
+/** The kinds the AI review fills across the documents. */
+export type TagsReviewKind = Extract<TagKind, 'label' | 'annotation' | 'issue'>;
+/** What the tag editor is given: the tag to edit, and what to do once a new one is made. */
+export interface TagEditorSlotProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    tag: TagResponse | undefined;
+    /** The workspace's tags (saved searches aside): what a tag can be nested under. */
+    tags: TagResponse[];
+    /** A new tag was made: open it. */
+    onCreated: (tagId: string) => void;
+}
+export interface ConnectedTagsPageProps {
+    /** Documents whose people and organisations are still being extracted. */
+    extractingDocIds?: readonly string[];
+    /** Open a fact. Absent: facts are listed, not opened. */
+    onOpenFact?: (factId: string) => void;
+    /** Open Smart Search: the saved searches' action. Absent: none. */
+    onOpenSmartSearch?: () => void;
+    /**
+     * Have the AI fill a kind's tags (or the open tag) across the documents: the labels',
+     * annotations' and issues' action. Absent: none.
+     */
+    onReview?: (target: {
+        kind: TagsReviewKind;
+        tag?: {
+            id: string;
+            name: string;
+        };
+    }) => void;
+    /** The tag editor (a dialog). Absent: tags are not edited here. */
+    renderTagEditor?: (props: TagEditorSlotProps) => ReactNode;
+}
+export declare function ConnectedTagsPage({ extractingDocIds, onOpenFact, onOpenSmartSearch, onReview, renderTagEditor, }: ConnectedTagsPageProps): import("react").JSX.Element;

package/dist/connection/tags/DocTagPassages.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The passages a tag's link to a document cites ("2 passages" under a tag on the Tags page), shown
+ * like a fact's sources: hovering or clicking the count opens a popover listing them (page +
+ * excerpt); a passage opens the document in the viewer at that passage, highlighted, exactly like a
+ * chat or fact citation; a cited document's name opens it; a whole-document citation just opens it.
+ *
+ * The citations are the doctag's own (`doctags[].citations` of the workspace's documents);
+ * excerpts are read live from the documents (`usePassageQuotes`); the presentation is the facts'
+ * (`FactSourcesPanel`, `FactSourceGroup`, `FactPassageItem`).
+ */
+import type { components } from '@arbidocs/client';
+type DocResponse = components['schemas']['DocResponse'];
+export interface DocTagPassagesProps {
+    /** The tagged document. */
+    docId: string;
+    /** The tag whose link to the document cites the passages. */
+    tagId: string;
+    /** The count's text ("2 passages"). */
+    label: string;
+    /** The workspace's documents by id (the doctag's citations, the cited documents' names). */
+    docOf: (docId: string) => DocResponse | undefined;
+    testId?: string;
+}
+export declare function DocTagPassages({ docId, tagId, label, docOf, testId }: DocTagPassagesProps): import("react").JSX.Element;
+export {};

package/dist/connection/tags/GlossaryExport.d.ts

@@ -0,0 +1,7 @@
+export interface GlossaryExportProps {
+    /** The Definitions label. */
+    labelId: string;
+    /** A cited document's name (a definition's source). */
+    nameOf: (docId: string) => string | null | undefined;
+}
+export declare function GlossaryExport({ labelId, nameOf }: GlossaryExportProps): import("react").JSX.Element;

package/dist/connection/tags/TagCombineFilter.d.ts

@@ -0,0 +1,14 @@
+import { type TagKind, type TagResponse } from '@arbidocs/sdk/browser';
+import { type TagCombination } from './tagCombine';
+export interface TagCombineFilterProps {
+    tags: readonly TagResponse[];
+    combination: TagCombination;
+    onChange: (combination: TagCombination) => void;
+    /** The kinds whose tags the menu lists (the open view's). */
+    kinds: readonly TagKind[];
+    /** Trigger styling (e.g. flush inside the filter box, as on the Files page). */
+    triggerClassName?: string;
+}
+export declare function TagCombineFilter({ tags, combination, onChange, kinds, triggerClassName, }: TagCombineFilterProps): import("react").JSX.Element;
+/** Every tag the filter includes or excludes, whichever kind it is, each removable; and Clear. */
+export declare function TagFilterChips({ tags, combination, onChange, }: Pick<TagCombineFilterProps, 'tags' | 'combination' | 'onChange'>): import("react").JSX.Element | null;

package/dist/connection/tags/TagPlacement.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Where a tag sits and who sees it, on its page: shared with the workspace or private, and (labels
+ * and annotations) the tag it is nested under — "Top level" or "Under …", among the tags of its
+ * kind that may be a parent (never itself or a sub-tag of its own, never a nested one: nesting is
+ * two levels deep). A tag with sub-tags stays at the top level. Issues, people and organisations
+ * are flat. Data-free: the host saves the change.
+ */
+import { type TagChange, type TagResponse } from '@arbidocs/sdk/browser';
+export interface TagPlacementProps {
+    tag: TagResponse;
+    /** The workspace's tags. */
+    tags: readonly TagResponse[];
+    /** Save a change (`parent_ext_id: null` moves it to the top level); `done` says what it did. */
+    onChange: (change: Pick<TagChange, 'shared' | 'parent_ext_id'>, done: string) => void;
+}
+export declare function TagPlacement({ tag, tags, onChange }: TagPlacementProps): import("react").JSX.Element;