@arbidocs/blocks 0.4.146 → 0.4.150

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

@@ -0,0 +1,32 @@
+/**
+ * useAddonPurchase — buy one add-on block (+£25 of AI usage or +25 GB) for a Pro project and tell
+ * the user what happened. The monthly usage cap limits automatic top-ups only, so it never refuses a block
+ * bought here. The block is charged now for the current period and then renews every
+ * period until the user reduces it. Shared by the add-on confirm dialog (project Add-ons card,
+ * quota-exceeded modal).
+ *
+ *  - `paid`             → the block is live now.
+ *  - `requires_action`  → the bank wants 3-D Secure: open Stripe's hosted invoice in a new tab;
+ *                         the block is added once confirmed (the next refresh picks it up).
+ *  - 402 `{code, message}` (declined / no card / no billing address) → the
+ *    refusal template ("… Nothing was charged. …"); any other failure leaves the outcome unknown:
+ *    `onUnknownError` lets the caller check the project before saying what happened.
+ */
+export type AddonKind = 'ai_usage' | 'storage';
+export type AddonErrorCode = 'PAYMENT_DECLINED' | 'PAYMENT_METHOD_REQUIRED' | 'BILLING_ADDRESS_REQUIRED';
+/** The user-facing message for a failed add-on request (402 detail object or plain detail). */
+export declare function addonErrorMessage(error: unknown): string;
+/** The refusal for a charge the backend turned down (402 with a known code), else null. */
+export declare function chargeRefusalMessage(error: unknown): string | null;
+/** The 402 code of a failed add-on request, if it has one. */
+export declare function addonErrorCode(error: unknown): AddonErrorCode | null;
+export declare function useAddonPurchase(): {
+    buy: (kind: AddonKind, projectExtId: string, options?: {
+        onPaid?: () => void;
+        onRequiresAction?: () => void;
+        onError?: (code: AddonErrorCode | null) => void;
+        /** A failure that doesn't say whether the charge went through (timeout, 5xx). */
+        onUnknownError?: () => void;
+    }) => void;
+    isPending: boolean;
+};

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

@@ -0,0 +1,11 @@
+/**
+ * useAutoRefreshPendingProjects
+ *
+ * Auto-refreshes owned projects stuck at subscription="none" (checkout
+ * completed but not yet synced). Skips member-of projects: refresh requires
+ * owner, and non-owner projects already have `subscription` blanked to
+ * "none" by the backend regardless of real state.
+ *
+ * Each project is refreshed at most once per mount (refreshedRef guard).
+ */
+export declare function useAutoRefreshPendingProjects(): void;

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

@@ -0,0 +1,30 @@
+/**
+ * useCheckoutQuote — the tax-inclusive total of a plan purchase for the billing country (and
+ * ZIP / postcode where the tax depends on it), from the backend's Stripe Tax quote. Shown by
+ * `CheckoutTotal` before Stripe opens.
+ */
+import type { PlanInterval } from './plan-pricing';
+import { type TaxQuote } from './tax-quote';
+export interface CheckoutQuoteState {
+    quote?: TaxQuote;
+    isLoading: boolean;
+    /** Show the ZIP / postcode field. */
+    showPostcode: boolean;
+    /** Why there is no total (e.g. "Enter your ZIP / postal code to see the total."). */
+    error: string | null;
+    /** Continue to payment: priced, or the pricing failed for a reason other than the address. */
+    canContinue: boolean;
+}
+/**
+ * Prices the plan, plus any add-on blocks picked at checkout (one period of each), for the billing address.
+ * `projectExtId` for an existing project.
+ */
+export declare function useCheckoutQuote({ projectExtId, interval, country, postalCode, aiBlocks, storageBlocks, enabled, }: {
+    projectExtId?: string | null;
+    interval: PlanInterval;
+    country: string;
+    postalCode: string;
+    aiBlocks?: number;
+    storageBlocks?: number;
+    enabled?: boolean;
+}): CheckoutQuoteState;

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

@@ -0,0 +1,12 @@
+/**
+ * Opens a fresh Stripe billing-portal link for a project in a new tab.
+ *
+ * The tab is opened synchronously inside the click: browsers only allow
+ * window.open() during the user gesture, and the portal link arrives after an
+ * await. The tab starts on about:blank and is pointed at the Stripe URL once the
+ * link is ready.
+ */
+export declare function useOpenBillingPortal(): {
+    open: (projectExtId: string) => void;
+    isPending: boolean;
+};

package/dist/connection/calendar/CalendarSettingsDialog.d.ts

@@ -1,6 +1,6 @@
 import { type CalendarSettings } from '@arbidocs/react';
 import { type CalendarListItem } from '../../calendar';
-export type CalendarSettingsTab = 'general' | 'accounts' | 'access' | 'booking' | 'rooms';
+export type CalendarSettingsTab = 'general' | 'accounts' | 'booking' | 'rooms';
 export interface CalendarSettingsDialogProps {
     open: boolean;
     settings: CalendarSettings;

package/dist/connection/connectors/ConnectedAppsSettings.d.ts

@@ -0,0 +1,24 @@
+/**
+ * ConnectedAppsSettings
+ *
+ * "Connected Apps" settings tab — lets users connect their legal tools
+ * (iManage, CoCounsel, Everlaw, CourtListener, …) so the ARBI agent can
+ * query them directly during a conversation.
+ *
+ * Architecture: calls /v1/connectors (catalog) and /v1/connectors/me (user's
+ * installed connectors) to build the list. Each card shows the vendor, its
+ * connection status, and a Connect / Disconnect action.
+ *
+ * OAuth flow: clicking "Connect" navigates the browser to
+ * /v1/connectors/{vendor}/authorize, which redirects to the vendor's OAuth
+ * consent page. After the user grants access the vendor redirects back to
+ * /v1/connectors/{vendor}/callback, which stores the encrypted token and
+ * redirects to /settings/connected-apps?connected={vendor}.
+ */
+export interface ConnectedAppsSettingsProps {
+    /** The vendor an OAuth return just connected (`?connected=`): badged for 4 s, then cleared. */
+    justConnectedVendor?: string | null;
+    /** The badge is done: forget the just-connected vendor. */
+    onJustConnectedSeen?: () => void;
+}
+export declare function ConnectedAppsSettings({ justConnectedVendor, onJustConnectedSeen, }: ConnectedAppsSettingsProps): import("react").JSX.Element;

package/dist/connection/connectors/ConnectedDriveSyncDialog.d.ts

@@ -0,0 +1,12 @@
+import { type ConnectorCatalogEntry, type UserConnectorEntry } from '@arbidocs/react';
+export interface ConnectedDriveSyncDialogProps {
+    catalog: ConnectorCatalogEntry;
+    userConnector: UserConnectorEntry | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** When set, hide the workspace picker and force sync onto this workspace. */
+    lockedWorkspaceExtId?: string;
+    /** Fired after a successful enable, with the workspace the sync now targets. */
+    onEnabled?: (workspaceExtId: string) => void;
+}
+export declare function ConnectedDriveSyncDialog({ catalog, userConnector, open, onOpenChange, lockedWorkspaceExtId, onEnabled, }: ConnectedDriveSyncDialogProps): import("react").JSX.Element;

package/dist/connection/connectors/ConnectedMailboxSyncDialog.d.ts

@@ -0,0 +1,12 @@
+import { type ConnectorCatalogEntry, type UserConnectorEntry } from '@arbidocs/react';
+export interface ConnectedMailboxSyncDialogProps {
+    catalog: ConnectorCatalogEntry;
+    userConnector: UserConnectorEntry | undefined;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** When set, hide the workspace picker and force sync onto this workspace. */
+    lockedWorkspaceExtId?: string;
+    /** Fired after a successful enable, with the workspace the sync now targets. */
+    onEnabled?: (workspaceExtId: string) => void;
+}
+export declare function ConnectedMailboxSyncDialog({ catalog, userConnector, open, onOpenChange, lockedWorkspaceExtId, onEnabled, }: ConnectedMailboxSyncDialogProps): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export { ConnectedAppsSettings, type ConnectedAppsSettingsProps } from './ConnectedAppsSettings';
+export { ConnectedMailboxSyncDialog, type ConnectedMailboxSyncDialogProps, } from './ConnectedMailboxSyncDialog';
+export { ConnectedDriveSyncDialog, type ConnectedDriveSyncDialogProps, } from './ConnectedDriveSyncDialog';
+export { BACKFILL_OPTIONS, formatLastSync, windowLabel } from './sync-labels';

package/dist/connection/connectors/sync-labels.d.ts

@@ -0,0 +1,21 @@
+/** Labels of a connector sync: the backfill windows and "last synced" times. */
+export declare const BACKFILL_OPTIONS: readonly [{
+    readonly value: "1";
+    readonly label: "Last 1 day";
+}, {
+    readonly value: "7";
+    readonly label: "Last 7 days";
+}, {
+    readonly value: "30";
+    readonly label: "Last 30 days";
+}, {
+    readonly value: "90";
+    readonly label: "Last 90 days";
+}, {
+    readonly value: "365";
+    readonly label: "Last year";
+}];
+/** Human-friendly "3d ago" style relative time; falls back to the raw ISO on parse failure. */
+export declare function formatLastSync(iso: string): string;
+/** Label for a backfill window in days (e.g. 1 -> "Last 1 day"). */
+export declare function windowLabel(days: number | null): string;

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

@@ -0,0 +1,50 @@
+/**
+ * The Facts page: the open workspace's facts — what it knows, a date, a decision, a preference —
+ * written by hand or kept by the assistant. A table (with labels, sources, verified and shared
+ * toggles, inline edits and bulk actions), a calendar and a timeline of the dated ones, and Smart
+ * Search when the host has one. A fact is written or edited in the composer above them: its text
+ * (rich markdown), its date, labels, sources (whole documents or passages picked in the viewer),
+ * and whether it is shared and verified.
+ *
+ * Data is `@arbidocs/react` (facts, tags) and the connected workspace documents. The host plugs in
+ * what lives elsewhere in it (see `types.ts`): the current chat's facts, the viewer's passage
+ * collection, where the view choices are kept, a request from another surface, and its own labels
+ * panel, export and Smart Search.
+ */
+import { type ReactNode } from 'react';
+import type { FactCreator, LookupUser } from './factPageColumns';
+import type { FactPassageCollector, FactsChat, FactsPageRequest, FactsPageSlots, FactsPageView } from './types';
+/** Who may do something to a fact, by its creator's id. */
+export type FactCreatorCheck = (creatorExtId: string | null | undefined) => boolean;
+export interface ConnectedFactsPageProps extends FactsPageSlots {
+    /** The current chat's facts (absent: no In chat column, filter or bulk action). */
+    chat?: FactsChat;
+    /** The viewer's passage collection (absent: citing a document opens it). */
+    collector?: FactPassageCollector;
+    /** Where the view choices are kept (default: in the page). */
+    view?: FactsPageView;
+    /** A one-off request from another surface; each part done is reported. */
+    request?: FactsPageRequest;
+    onRequestHandled?: (part: keyof FactsPageRequest) => void;
+    /** Open the labels panel for the selected facts (with `renderLabelsPanel`). */
+    onOpenLabels?: () => void;
+    /**
+     * Who may change who sees a fact (default: its creator) and who may reword or delete it (default:
+     * its creator; a host adds the workspace's owners).
+     */
+    permissions?: {
+        canChangeSharing: FactCreatorCheck;
+        canRewrite: FactCreatorCheck;
+    };
+    /** A creator by id (default: the workspace's members). */
+    lookupUser?: LookupUser;
+    /** A creator's avatar (default: the shared one). */
+    renderUser?: (user: FactCreator | null) => ReactNode;
+}
+/** One id for the grid's persisted column state and its row-height density.
+ *  v11: reset so the Dates column opens beside the fact text.
+ *  v12: reset so the table opens in date order (a saved column state would override the default sort).
+ *  v13: the Pinned column became In chat (colId `in_chat`).
+ *  Bump to reset state. */
+export declare const FACTS_GRID_ID = "facts-grid-v13";
+export declare function ConnectedFactsPage({ chat, collector, view: hostView, request, onRequestHandled, onOpenLabels, permissions, lookupUser: hostLookupUser, renderUser, renderLabelsPanel, renderExport, renderSmartSearch, emptyStateExtra, }: ConnectedFactsPageProps): import("react").JSX.Element;

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

@@ -0,0 +1,57 @@
+/**
+ * FactMarkdownEditor
+ *
+ * A WYSIWYG editor for a fact: the text is edited as rendered markdown (via the
+ * shared MDXEditor, same engine the document artifacts use), and the fact's
+ * source citations are preserved and managed beneath it exactly as the packaged
+ * CitationEditor did — per-document rows with page refs and a remove control,
+ * and the document picker wired to the viewer's passage-collection flow.
+ *
+ * The editor is heavy (Lexical), so it is lazy-loaded. It adopts its markdown on mount only, so
+ * the parent bumps `editorKey` each time the composer opens to reload the right fact's text.
+ */
+import type { components } from '@arbidocs/client';
+import { type ReactNode } from 'react';
+import type { FactPassageCollector } from './types';
+type CitationSources = components['schemas']['CitationSources'];
+type DocResponse = components['schemas']['DocResponse'];
+export interface FactMarkdownEditorProps {
+    /** Remount key so the editor adopts a different fact's markdown on open. */
+    editorKey: string;
+    value: string;
+    citations: CitationSources | null;
+    onChange: (text: string, citations: CitationSources | null) => void;
+    /** Open a document in the viewer, armed to collect passages for this fact.
+     *  `toggle: false` always opens (the picker's list); otherwise clicking the
+     *  document already in view closes it. */
+    onCiteDocument: (docExtId: string, opts?: {
+        toggle?: boolean;
+    }) => void;
+    /** The viewer's passage collection, while a source's popover is open. */
+    collector?: FactPassageCollector;
+    /** Resolved cited documents, keyed by external id. */
+    citedDocs?: Record<string, DocResponse>;
+    /** The document currently on display in the viewer (null when closed). Its
+     *  Source row is highlighted so it's clear which cited doc you're reading. */
+    viewingDocId?: string | null;
+    /** The workspace document picker (Sources title + combobox), injected.
+     *  `sourcesToggle` is the control that opens the sources popup (every cited
+     *  document with its passages) — place it in front of the combobox (null when
+     *  the fact has no sources to show). */
+    renderDocumentPicker: (onSelect: (docExtId: string) => void, selectedIds: string[], onOpen: (docExtId: string) => void, sourcesToggle: ReactNode, 
+    /** True while the Sources popup is open — shut the picker's list then. */
+    sourcesOpen: boolean) => ReactNode;
+    /** The markdown MDXEditor produces on mount (its canonical round-trip of
+     *  `value`) — use as the "unchanged" baseline for a dirty check. */
+    onNormalized?: (normalized: string) => void;
+    /** Keep the sources toggle in place (disabled) even when the fact has no
+     *  sources, so selecting different events doesn't change the Sources row
+     *  geometry (used by the timeline/calendar). */
+    reserveSourcesSpace?: boolean;
+    /** The fact section element the source Citation popovers portal into and are
+     *  kept within (see FactSourcesPopover), so it never spills over the sidebar. */
+    citationContainer?: HTMLElement | null;
+    'data-testid'?: string;
+}
+export declare function FactMarkdownEditor({ editorKey, value, citations, onChange, onCiteDocument, collector, citedDocs, viewingDocId, renderDocumentPicker, onNormalized, reserveSourcesSpace, citationContainer, 'data-testid': dataTestId, }: FactMarkdownEditorProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,38 @@
+/**
+ * The fact's sources as ONE popup off the "Sources" control in the Sources row — every cited
+ * document, each with the passages the fact draws from it listed beneath (page + excerpt), laid out
+ * like the chat's citations. Being a popover (not an in-flow list) it never pushes the rest of the
+ * composer up or down. Clicking a document opens it in the viewer; clicking a passage jumps to and
+ * highlights it there, exactly like a chat citation. Excerpts are resolved live
+ * (`usePassageQuotes`), never stored on the fact. The viewer side goes through the host's
+ * `FactPassageCollector`.
+ */
+import type { components } from '@arbidocs/client';
+import { type OrderResolver, type QuoteResolver } from '@arbidocs/react';
+import { type ReactNode } from 'react';
+import type { FactCitations } from '../../facts/fact-citations';
+import type { FactPassageCollector } from './types';
+type DocResponse = components['schemas']['DocResponse'];
+export interface FactSourcesPopoverProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    /** The Sources row (picker + the PopoverTrigger toggle) this popup hangs off. */
+    children: ReactNode;
+    /** Cited documents in citation order, each with its passages. */
+    citations: FactCitations;
+    citedDocs?: Record<string, DocResponse>;
+    quoteFor: QuoteResolver;
+    orderOf?: OrderResolver;
+    /** The document currently on display in the viewer (null when closed). */
+    viewingDocId?: string | null;
+    /** Open a document in the viewer, armed to collect passages for this fact. */
+    onCiteDocument: (docExtId: string) => void;
+    onRemoveDoc: (docExtId: string) => void;
+    /** The viewer's passage collection (absent: passages open the document, nothing is marked). */
+    collector?: FactPassageCollector;
+    /** The fact section the popover is portalled INTO and fenced WITHIN, so it
+     *  opens into the fact content rather than across the app sidebar. */
+    container?: HTMLElement | null;
+}
+export declare function FactSourcesPopover({ open, onOpenChange, children, citations, citedDocs, quoteFor, orderOf, viewingDocId, onCiteDocument, onRemoveDoc, collector, container, }: FactSourcesPopoverProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,2 @@
+import { type ArtifactMarkdownEditorProps } from '../../artifacts/editor/ArtifactMarkdownEditor';
+export default function FactTextEditor(props: Omit<ArtifactMarkdownEditorProps, 'dictation'>): import("react").JSX.Element;

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

@@ -0,0 +1,4 @@
+export declare const factNouns: () => {
+    SINGULAR: string;
+    PLURAL: string;
+};

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

@@ -0,0 +1,37 @@
+import type { ColDef } from 'ag-grid-community';
+import { type ReactNode } from 'react';
+import type { Fact } from './types';
+/** A fact's creator, as the page knows them. */
+export interface FactCreator {
+    external_id: string;
+    given_name?: string | null;
+    family_name?: string | null;
+    email?: string | null;
+    picture?: string | null;
+}
+/** Resolves a creator's external id to the user. */
+export type LookupUser = (externalId: string | null | undefined) => FactCreator | null;
+export interface FactGridContext {
+    lookupUser?: LookupUser;
+    /** The host's own creator avatar. */
+    renderUser?: (user: FactCreator | null) => ReactNode;
+    renderFactTags?: (fact: Fact, rowHeight?: number) => ReactNode;
+    openEdit?: (fact: Fact) => void;
+    removeFact?: (fact: Fact) => void;
+    /** Who may change who can see a fact: its creator or a workspace owner. */
+    canChangeSharing?: (fact: Fact) => boolean;
+    /** Who may reword a fact (it replaces the note): its creator or a workspace owner. */
+    canRewrite?: (fact: Fact) => boolean;
+    /** Whether the fact is in the current chat (read live: the column defs are built once). */
+    isInChat?: (fact: Fact) => boolean;
+}
+interface FactColumnCallbacks {
+    /** Add the fact to the current chat, or take it out (absent: no chat, no In chat column). */
+    onToggleInChat?: (fact: Fact) => void;
+    /** Whether the fact is in the current chat. */
+    isInChat?: (fact: Fact) => boolean;
+    onToggleConfirmed: (fact: Fact) => void;
+    onToggleShared: (fact: Fact) => void;
+}
+export declare function createFactPageColumns({ onToggleInChat, isInChat, onToggleConfirmed, onToggleShared, }: FactColumnCallbacks): ColDef<Fact>[];
+export {};

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

@@ -0,0 +1,127 @@
+/**
+ * What the connected Facts page shares with its host. The page reads and writes the facts itself
+ * (`@arbidocs/react`); a host plugs in what lives elsewhere in it: the current chat's facts, the
+ * document viewer's passage collection, where the page's view choices are kept, and the parts that
+ * are its own (the labels panel, export, Smart Search).
+ */
+import type { ReactNode } from 'react';
+import type { GridState } from 'ag-grid-community';
+import type { FactResponse } from '@arbidocs/sdk/browser';
+import type { TriState } from '../../settings/TriStateFilterMenu';
+import type { FactsSearchField } from '../../facts/FactsFilterInput';
+import type { FactsViewMode } from '../../facts/FactsViewToggle';
+export type Fact = FactResponse;
+/**
+ * The current chat's facts (absent: no chat, no In chat column). Adding is the host's to refuse
+ * (a budget, a duplicate) and to say why; it returns how many it added.
+ */
+export interface FactsChat {
+    /** The ids of the facts in the current chat. */
+    factIds: readonly string[];
+    add: (facts: Fact[]) => number;
+    remove: (factIds: string[]) => number;
+    /** The chat's facts budget, in characters (absent: no budget shown). */
+    budget?: {
+        used: number;
+        cap: number;
+    };
+}
+/** A passage picked in the viewer for the fact being written. */
+export interface CollectedPassage {
+    chunk_id: string;
+    page?: number | null;
+}
+/**
+ * The document viewer's passage collection: citing a document opens it in the viewer, and the
+ * passages picked (or unpicked) there land on the fact being written. Absent: citing a document
+ * opens it (`openDocument`) and sources are whole documents or passages already cited.
+ */
+export interface FactPassageCollector {
+    /** The document on display in the viewer (null when it is closed). */
+    displayedDocId: string | null;
+    /** The document passages are being collected from (null: not collecting). */
+    collectingDocId: string | null;
+    /** Passages picked in the viewer since the last `consumePicked`. */
+    picked: readonly CollectedPassage[];
+    /** Passages unpicked in the viewer since the last `consumeUnpicked`. */
+    unpicked: readonly string[];
+    consumePicked: () => void;
+    consumeUnpicked: () => void;
+    /** Open a document in the viewer, collecting for this fact (null: a new one). */
+    open: (docId: string, factId: string | null) => void;
+    /** Collect from a document already on display (null: stop collecting). */
+    collect: (docId: string | null) => void;
+    /** Close the viewer. */
+    close: () => void;
+    /** Mark the cited passages in the viewer while the sources list is open ([]: none). */
+    highlight: (chunkIds: string[]) => void;
+    /** Clear the passage being read in the viewer and its highlight. */
+    clearReading: () => void;
+}
+/**
+ * Where the page keeps its view choices, so they outlast leaving the page (default: kept in the
+ * page while it is mounted). Each pair is a value and its setter.
+ */
+export interface FactsPageView {
+    view: FactsViewMode;
+    setView: (view: FactsViewMode) => void;
+    /** The table's row height (px). */
+    rowHeight: number;
+    setRowHeight: (height: number) => void;
+    /** The timeline's label gutter width (px). */
+    labelWidth: number;
+    setLabelWidth: (width: number) => void;
+    /** The timeline zoom. */
+    zoom: number;
+    setZoom: (zoom: number) => void;
+    /** The filter box's text and what it searches. */
+    filterText: string;
+    setFilterText: (text: string) => void;
+    searchFields: FactsSearchField[];
+    setSearchFields: (fields: FactsSearchField[]) => void;
+    /** The quick filters (tri-state, by filter id). */
+    filters: Map<string, TriState>;
+    setFilters: (filters: Map<string, TriState>) => void;
+    /** The table's column state. */
+    gridState?: GridState;
+    setGridState?: (state: GridState) => void;
+}
+/** What the labels panel applies labels to: the selected facts. */
+export interface FactsLabelTarget {
+    noun: {
+        singular: string;
+        plural: string;
+    };
+    ids: string[];
+    /** How many facts carry a label. */
+    countFor: (tagId: string) => number;
+    apply: (tagIds: string[]) => Promise<void>;
+    clear: (tagIds: string[]) => Promise<void>;
+}
+/** A one-off request from another surface: show a view, start a fact, or bring one into view. */
+export interface FactsPageRequest {
+    view?: FactsViewMode | null;
+    compose?: boolean;
+    focusFactId?: string | null;
+}
+/** The host's own parts of the page. */
+export interface FactsPageSlots {
+    /** The labels panel for the selected facts (opened by `onOpenLabels`). */
+    renderLabelsPanel?: (target: FactsLabelTarget) => ReactNode;
+    /** Export the selected facts. */
+    renderExport?: (props: {
+        open: boolean;
+        onOpenChange: (open: boolean) => void;
+        items: {
+            extId: string;
+            label: string;
+        }[];
+    }) => ReactNode;
+    /** The Smart Search view (absent: no Smart Search). */
+    renderSmartSearch?: (props: {
+        selectedFactId: string | null;
+        onOpenFact: (factId: string) => void;
+    }) => ReactNode;
+    /** Under the empty state (e.g. "find facts in your documents"). */
+    emptyStateExtra?: ReactNode;
+}

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

@@ -0,0 +1,10 @@
+import type { CellValueChangedEvent } from 'ag-grid-community';
+import type { Fact } from './types';
+export declare function useFactActions(refetch: () => unknown): {
+    toggleShared: (m: Fact) => Promise<void>;
+    toggleConfirmed: (m: Fact) => Promise<void>;
+    remove: (m: Fact) => Promise<boolean>;
+    setFactTags: (fact: Fact, tagExtIds: string[]) => Promise<void>;
+    handleCellValueChanged: (event: CellValueChangedEvent<Fact>) => Promise<void>;
+    isDeleting: boolean;
+};

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

@@ -0,0 +1,54 @@
+/**
+ * The inline fact composer's state and behaviour: draft buffers, passage collection from the
+ * document viewer, create/update/delete, and the "dirty" check that gates Save.
+ */
+import type { components } from '@arbidocs/client';
+import { type RefObject } from 'react';
+import type { GridApi } from 'ag-grid-community';
+import { type FactDateFields } from '../../facts/fact-date';
+import type { Fact, FactPassageCollector } from './types';
+export declare function useFactComposer(notes: Fact[], remove: (fact: Fact) => Promise<boolean>, gridApiRef: RefObject<GridApi<Fact> | null>, collector: FactPassageCollector | undefined, 
+/** A request to start a fact (from another surface), and its done. */
+composeRequested: boolean, onComposeHandled: () => void): {
+    composing: boolean;
+    setComposing: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    draft: string;
+    setDraft: import("react").Dispatch<import("react").SetStateAction<string>>;
+    setBaselineText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    draftCitations: {
+        doc_ext_id: string;
+        version?: number | null;
+        chunks?: components["schemas"]["CitedChunk"][];
+    }[] | null;
+    setDraftCitations: import("react").Dispatch<import("react").SetStateAction<{
+        doc_ext_id: string;
+        version?: number | null;
+        chunks?: components["schemas"]["CitedChunk"][];
+    }[] | null>>;
+    draftTagIds: string[];
+    setDraftTagIds: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    draftDateFields: FactDateFields;
+    setDraftDateFields: import("react").Dispatch<import("react").SetStateAction<FactDateFields>>;
+    draftShared: boolean;
+    setDraftShared: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    draftConfirmed: boolean;
+    setDraftConfirmed: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    composerError: string | null;
+    setComposerError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    editingId: string | null;
+    composerSession: number;
+    editingIdRef: RefObject<string | null>;
+    displayedDocId: string | null;
+    resetComposer: () => void;
+    startNewFact: () => void;
+    saveComposer: () => Promise<void>;
+    deleteEditingFact: () => Promise<void>;
+    openEdit: (m: Fact) => void;
+    composerDirty: boolean;
+    citeDocument: (docExtId: string, target: string, opts?: {
+        toggle?: boolean;
+    }) => void;
+    setSourceCitationSession: (docExtId: string | null) => void;
+    isSaving: boolean;
+    DRAFT_TARGET: string;
+};