@arbidocs/blocks 0.4.147 → 0.4.151

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;

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

@@ -0,0 +1,36 @@
+/**
+ * The two views of the Tags page's main area: every tag of a kind as a table (`KindSection`), and
+ * one tag in full (`TagSection`) — its placement and actions, its sub-tags as rows, 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.
+ */
+import type { ReactNode } from 'react';
+import { type TagKind, type TagResponse } from '@arbidocs/sdk/browser';
+import { type TagTableFilter } from './ConnectedTagTable';
+/** What both views share: the filter and where a tagged item opens. */
+export interface TagsPageViewContext {
+    filter: TagTableFilter;
+    onOpenTag: (tagId: string) => void;
+    onOpenFact?: (factId: string) => void;
+}
+/** Every tag of a kind as a table, under the kind's heading (the picker at its right). */
+export declare function KindSection({ kind, ctx, extractingCount, picker, }: {
+    kind: TagKind;
+    ctx: TagsPageViewContext;
+    extractingCount: number;
+    picker: ReactNode;
+}): import("react").JSX.Element;
+/** One tag in full: its placement and actions, its sub-tags, and everything tagged with it. */
+export declare function TagSection({ tag, tags, ctx, actions, onEdit, onDelete, onBack, renderPassages, picker, }: {
+    tag: TagResponse;
+    tags: readonly TagResponse[];
+    ctx: TagsPageViewContext;
+    /** Its own actions before Edit (e.g. printing the glossary of the Definitions label). */
+    actions?: ReactNode;
+    /** Edit it. Absent: no Edit. */
+    onEdit?: () => void;
+    onDelete: () => void;
+    onBack: () => void;
+    renderPassages: (docId: string, label: string) => ReactNode;
+    picker: ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,55 @@
+/**
+ * The Tags page's filter: a tri-state choice per tag (include / exclude, as the Files filter), one
+ * state for the whole page whichever kind is open, and what it lets through across the workspace —
+ * documents, facts and threads. Matching is the tri-state filter's own evaluator
+ * (`applyInvertedIndexFilter`): include is OR across tags, exclude drops a match and wins over
+ * include. Every view then shows only the tagged items that pass (`narrowTagRow`,
+ * `narrowTagTable`), and only the tags with some left.
+ */
+import { type TagNode, type TagResponse } from '@arbidocs/sdk/browser';
+import type { TriState } from '../../settings/TriStateFilterMenu';
+import type { TagTableData, TagTableRow } from '../../tags/tagTableModel';
+export type TagCombination = Map<string, TriState>;
+/** Whether any tag is included or excluded. */
+export declare const isCombining: (combination: TagCombination) => boolean;
+/**
+ * The next combination after the user changes it: a tag newly included or excluded brings its
+ * sub-tags along (each can then be unset on its own); a tag set back to neither takes along the
+ * sub-tags that still carry the state it had.
+ */
+export declare function cascadeTagCombination(tags: readonly TagNode[], previous: TagCombination, next: TagCombination): TagCombination;
+/** What the filter lets through: the ids of the documents, facts and threads that pass. */
+export interface TagFilterMatches {
+    docs: Set<string>;
+    facts: Set<string>;
+    threads: Set<string>;
+}
+/** The workspace's tagged items the filter reads: each item's id and the tags it carries. */
+export interface TaggedItems {
+    documents: ReadonlyArray<{
+        id: string;
+        tagIds: readonly string[];
+    }>;
+    facts: ReadonlyArray<{
+        id: string;
+        tagIds: readonly string[];
+    }>;
+    threads: ReadonlyArray<{
+        id: string;
+        tagIds: readonly string[];
+    }>;
+}
+/**
+ * What the filter lets through (undefined: no filter). Every list is the workspace's own, so an
+ * exclusion applies to everything, not only to what an included tag links.
+ */
+export declare function tagCombinationMatches(combination: TagCombination, items: TaggedItems): TagFilterMatches | undefined;
+/**
+ * Narrow one tag's tagged items to what the filter lets through (`matches`; absent: no filter),
+ * counting what is left; `shown` keeps that many of each list (a table cell lists a few).
+ */
+export declare function narrowTagRow(row: TagTableRow, matches: TagFilterMatches | undefined, shown?: number): TagTableRow;
+/** A table under the filter: each row narrowed, and only the rows with tagged items left. */
+export declare function narrowTagTable(table: TagTableData | undefined, matches: TagFilterMatches | undefined, shown?: number): TagTableData | undefined;
+/** A tag's values as text a filter can match (a linked tag by its name). */
+export declare function tagValueText(tag: Pick<TagResponse, 'field_values'>, nameOf: (id: string) => string | undefined): string;

package/dist/connection/useConnectedWorkNotifications.d.ts

@@ -1,27 +1,10 @@
-import type { components } from '@arbidocs/client';
-export type WorkNotificationTarget = {
-    kind: 'conversation';
-    workspaceId: string;
-    conversationId: string;
-    messageId?: string;
-} | {
-    kind: 'workflow';
-    workspaceId?: string;
-    workflowId: string;
-}
-/** A draft an agent left for the user (`mail_draft_ready`): open it, e.g. `ConnectedMailbox draftId`. */
- | {
-    kind: 'mail_draft';
-    draftId: string;
-    mailbox?: string;
-};
-/** Persisted work notifications in the shared bell; the consumer owns navigation. */
-export declare function useConnectedWorkNotifications(onOpen: (target: WorkNotificationTarget) => void | Promise<void>): {
+import { type NotificationTarget } from '@arbidocs/react';
+/**
+ * Persisted work notifications (mentions, finished and failed runs, access requests, drafts an
+ * agent left) in the shared bell. What each says and where it leads is the one shared mapping,
+ * `describeServerNotification`; the consumer turns a {@link NotificationTarget} into its routes.
+ */
+export declare function useConnectedWorkNotifications(onOpen: (target: NotificationTarget) => void | Promise<void>): {
     onMarkRead: (id: string) => void;
     onMarkAllRead: () => void;
 };
-/** Route from explicit IDs; encrypted task text is never needed for a link. */
-export declare function mapWorkNotification(note: components['schemas']['NotificationResponse']): {
-    title: string;
-    target: WorkNotificationTarget;
-} | null;

package/dist/connection/viewer/ConnectedDocumentToolsProvider.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The PDF document tools (markup, Freeze, signing, signature requests, productions) on the
+ * signed-in session, for any host: the API client, the signed-in user, the host's notices and
+ * document opening (`BlocksEnvironment`), and the shared caches a change refreshes. A host with its
+ * own binding (its own lists to refresh, an XHR upload with progress, Mail) keeps it: an enclosing
+ * `DocumentToolsProvider` wins.
+ */
+import { type ReactNode } from 'react';
+export declare function ConnectedDocumentToolsProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/connection/viewer/ConnectedDocumentViewer.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The whole document viewer on the signed-in session: a document (or one of its versions, read
+ * only) as its PDF, its text, the Word editor, a sheet, an image, a recording or a live artifact;
+ * its versions and comparisons; markup, signing and signature requests; sharing, Email, Translate
+ * and Finalise. Runs under any host (`useConnectedWorkspace`): the open document, tab and comparison
+ * are the session state's, navigation the `BlocksEnvironment`'s, and what only the host knows comes
+ * through `DocumentViewerSupportProvider`.
+ */
+import { type ReactNode } from 'react';
+export interface ConnectedDocumentViewerProps {
+    /**
+     * The document, or a version reference `doc-…@v{n}` (a citation, a "made from v2" link): an
+     * earlier version opens read-only. Default: the session state's viewing document.
+     */
+    documentId?: string;
+    /** Controls at the right end of the header (a panel's dock / pop-out switcher). */
+    headerActions?: ReactNode;
+    /** Where html/react artifacts load their sandbox runtime from. */
+    artifactRuntimeUrl?: string;
+}
+export declare function ConnectedDocumentViewer(props: ConnectedDocumentViewerProps): import("react").JSX.Element | null;

package/dist/connection/viewer/FinaliseTranslationButton.d.ts

@@ -0,0 +1,15 @@
+interface TranslationDocument {
+    external_id: string;
+    derived_from?: ReadonlyArray<{
+        role?: string | null;
+    }> | null;
+}
+/**
+ * Finalise: save the translation's current version as a new PDF document, labelled "Translation" and
+ * linked to the original. The editable translation stays as it is; the new PDF opens.
+ */
+export declare function FinaliseTranslationButton({ document, isCompact, }: {
+    document: TranslationDocument | undefined;
+    isCompact: boolean;
+}): React.ReactElement | null;
+export {};

package/dist/connection/viewer/ViewerPdfPane.d.ts

@@ -0,0 +1,46 @@
+/**
+ * The PDF (or media) body of the document viewer: loading and failure states, the image, audio and
+ * video players, and the PDF with its tools — the markup layer, signature placement, a signature
+ * request being prepared or signed.
+ */
+import type { SignatureAppearance, SignatureRequest, useDocumentMarkup } from '@arbidocs/react/document-tools';
+import { type PdfViewerProps } from '@arbidocs/react/viewers';
+import { type ViewedDocument } from './useViewedDocument';
+/** A signature request: the author placing fields, or a signer walked through theirs. */
+export type SignatureFlow = {
+    kind: 'prepare';
+    draft?: SignatureRequest;
+} | {
+    kind: 'sign';
+    request: SignatureRequest;
+} | null;
+/**
+ * The kit PDF viewer, reporting the page read into the session state; in a detached window its
+ * pages render without the opener's web fonts (canvas text in another document cannot use them).
+ */
+export declare function SessionPdfViewer(props: Omit<PdfViewerProps, 'onPageChange' | 'disableFontFace'>): import("react").JSX.Element;
+export interface ViewerPdfPaneProps {
+    documentId: string;
+    doc: ViewedDocument;
+    pdfBlob: Blob | null;
+    isPdfLoading: boolean;
+    pdfError: unknown;
+    onDownload: () => void;
+    viewerProps: {
+        currentPage: number | undefined;
+        onLoadSuccess: (pages: number) => void;
+        scrollTrigger: number;
+        zoom: number;
+        onZoomChange: (zoom: number) => void;
+    };
+    signatureFlow: SignatureFlow;
+    onSignatureFlow: (flow: SignatureFlow) => void;
+    currentUserId: string | undefined;
+    placingSignature: boolean;
+    onPlacingDone: (appearance?: SignatureAppearance) => void;
+    annotating: boolean;
+    markup: ReturnType<typeof useDocumentMarkup>;
+    pdfSnapshotNumber: number | undefined;
+    isSigned: boolean;
+}
+export declare function ViewerPdfPane({ documentId, doc, pdfBlob, isPdfLoading, pdfError, onDownload, viewerProps, signatureFlow, onSignatureFlow, currentUserId, placingSignature, onPlacingDone, annotating, markup, pdfSnapshotNumber, isSigned, }: ViewerPdfPaneProps): import("react").JSX.Element;

package/dist/connection/viewer/parsed/ParsedPassage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ParsedPassage: binds one parsed chunk to the `HtmlPassage` block (markdown body, citation
+ * entity pills, copy/link/label/navigator actions). Memoized so selecting one passage does not
+ * re-parse the markdown of the others.
+ */
+import type { ProcessedChunk } from '@arbidocs/react/viewers';
+import type { PassageLabel } from './useDocumentLabels';
+export interface ParsedPassageProps {
+    chunk: ProcessedChunk;
+    pageNumber: number | null;
+    isHighlighted: boolean;
+    isSelected: boolean;
+    /** One of a fact's cited passages, listed in an open Citation popover. */
+    isCitationHighlight: boolean;
+    /** The cited passage currently being read from the Citation popover. */
+    isActiveCitation: boolean;
+    /** A fact's Citation popover drives the highlights; its shades win over the selection fill. */
+    factCitationActive: boolean;
+    isCitationMode: boolean;
+    runIsStart: boolean;
+    runIsEnd: boolean;
+    /** Last passage index of the run; set only on the run's first member. */
+    runEndIndex: number | undefined;
+    onChunkClick: ((chunkId: string, extendFromAnchor: boolean) => void) | undefined;
+    formatChunkWithCitation: (content: string, pageNumber: number | undefined, chunkExtId: string | undefined) => string;
+    getPassageDeepLink: (chunkExtId: string | undefined) => string | null;
+    copyToClipboard: (text: string, metadata: {
+        type: 'passage' | 'link';
+        documentTitle: string;
+        pageNumber: number | undefined;
+        passageIndex: number | undefined;
+        passageContent: string;
+        href?: string;
+    }) => void;
+    /** Open the document's passages in the host's navigator. Absent: not offered. */
+    onOpenNavigator: (() => void) | undefined;
+    /** Labels applied to this passage. */
+    labels: PassageLabel[];
+    /** The label currently being walked, when it marks this passage. */
+    activeTagColor: string | undefined;
+    /** Open the tagging panel for this passage. */
+    onTagPassage: ((chunkExtId: string) => void) | undefined;
+    /** Walk a label's passages (the label mark's Show row). */
+    onShowLabel: ((tagExtId: string) => void) | undefined;
+    /** Take a label off this passage (the label mark's Remove row). */
+    onRemoveLabel: ((chunkExtId: string, tagExtId: string) => void) | undefined;
+}
+export declare const ParsedPassage: import("react").NamedExoticComponent<ParsedPassageProps>;

package/dist/connection/viewer/parsed/ParsedTextView.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The text view of a document: its parsed passages, page by page, with labels, citation picking,
+ * passage links and copying, and the passage a citation opened it at. Data and behaviour live in
+ * the hooks (labels, citation selection, lazy pages); the markup is the blocks HtmlViewer parts.
+ */
+export interface ParsedTextViewProps {
+    documentId: string;
+    stage?: 'marker' | 'subchunk' | 'final';
+    onLoadSuccess?: (totalPages: number) => void;
+    /** Incremented to trigger scroll to current page */
+    scrollTrigger?: number;
+    /** Text zoom, a multiplier of the normal size (1 = 100%). */
+    zoom?: number;
+    /** Called by pinch and double-tap. */
+    onZoomChange?: (zoom: number) => void;
+}
+export declare function ParsedTextView({ documentId, stage, onLoadSuccess, scrollTrigger, zoom, onZoomChange, }: ParsedTextViewProps): import("react").JSX.Element;

package/dist/connection/viewer/parsed/PassageTagPanel.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The passage tagging panel: the `TagPassagePanel` block bound to the passage's labels and fields
+ * (apply, remove, a note per passage).
+ */
+import type { components } from '@arbidocs/client';
+type DocTag = components['schemas']['DocTagResponse'];
+interface PassageTagPanelProps {
+    documentId: string;
+    chunkExtId: string;
+    chunkContent: string;
+    pageNumber?: number;
+    documentDoctags: DocTag[];
+    onClose: () => void;
+    /** Called when a tag is selected to show all chunks with that tag */
+    onViewTaggedChunks?: (tagExtId: string) => void;
+}
+export declare function PassageTagPanel({ documentId, chunkExtId, chunkContent, pageNumber, documentDoctags, onClose, onViewTaggedChunks, }: PassageTagPanelProps): import("react").JSX.Element;
+export {};

package/dist/connection/viewer/parsed/citation-line.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utility functions for formatting citations
+ */
+interface ChunkCopyData {
+    content: string;
+    documentTitle?: string;
+    documentDate?: string;
+    pageNumber?: number;
+    chunkId?: string;
+}
+/**
+ * Formats a citation in basic academic format
+ * @param data - The chunk and document data
+ * @returns Formatted citation string
+ */
+export declare function formatCitation(data: ChunkCopyData): string;
+export {};

package/dist/connection/viewer/parsed/document-tags.d.ts

@@ -0,0 +1,8 @@
+import type { components } from '@arbidocs/client';
+type ScopedTag = Pick<components['schemas']['TagResponse'], 'kind' | 'doctag_count' | 'facttag_count'>;
+/**
+ * A tag of the documents' vocabulary: not a saved search, and used on documents or not used
+ * anywhere yet (a tag used only on facts belongs to the facts').
+ */
+export declare function isDocumentTag(tag: ScopedTag): boolean;
+export {};