@arbidocs/blocks 0.3.110

package/dist/index.d.cts

@@ -0,0 +1,1213 @@
+import { UseBoundStore, StoreApi } from 'zustand';
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+import * as _arbidocs_react from '@arbidocs/react';
+import { AiRunOptions, useArbi } from '@arbidocs/react';
+export { AiRunOptions, AiTaskStatus, ArtifactEvent, SearchChunk, Table, TableBody, TableCell, TableHead, TableHeader, TableRow, redlineStats, textToArtifact, toRedlineMarkdown } from '@arbidocs/react';
+import { ColDef, GridOptions, GridApi, CellValueChangedEvent, GridState } from 'ag-grid-community';
+import { LucideIcon } from 'lucide-react';
+import { Config, CustomField, Field, ComponentConfig } from '@measured/puck';
+
+/**
+ * The reusable AI-native law-firm prompt library.
+ *
+ * Deliberately opinionated, litigation-grade instructions: they demand citations
+ * to the source documents, hedge appropriately, and always frame the output as a
+ * draft for a regulated lawyer to review ("AI proposes, the lawyer disposes").
+ * Firm-specific register (name, jurisdiction, house language) is injected via
+ * {@link PromptConfig} so a second firm reuses the same library with its own
+ * voice — call {@link createPromptLibrary} once and share the result app-wide.
+ */
+interface MatterContext {
+    title: string;
+    client?: string;
+    court?: string;
+    claimNumber?: string;
+    practice?: string;
+    summary?: string;
+}
+/** Build a {@link MatterContext} from any matter-shaped record. */
+declare function matterToContext(m: {
+    title: string;
+    clientName?: string;
+    court?: string | null;
+    claimNumber?: string | null;
+    practice?: string;
+    summary?: string;
+}): MatterContext;
+/** Firm voice for the prompt library — everything firm-specific lives here. */
+interface PromptConfig {
+    /** The firm's name, e.g. "Clarum". */
+    firmName: string;
+    /** The legal system adjective used throughout, e.g. "English". */
+    jurisdiction?: string;
+    /** House writing language, e.g. "British English". */
+    language?: string;
+    /** How the reviewing professional is addressed, e.g. "qualified solicitor". */
+    reviewerTitle?: string;
+    /** Who signs off compliance/onboarding, e.g. "MLRO". */
+    complianceOfficer?: string;
+}
+type PromptLibrary = ReturnType<typeof createPromptLibrary>;
+/** The map of prompt builders (`prompts.brief(ctx)`, `prompts.revise(...)`, …). */
+type Prompts = PromptLibrary['prompts'];
+/**
+ * Build a firm-branded prompt library. Every prompt grounds on the supplied
+ * documents, cites sources, and is framed as a draft for a lawyer to review.
+ */
+declare function createPromptLibrary(config: PromptConfig): {
+    prompts: {
+        /** Executive brief of the matter, from the live bundle. */
+        brief: (m?: MatterContext) => string;
+        /** Sourced chronology of events. */
+        chronology: (m?: MatterContext) => string;
+        /** Disclosure / relevance + privilege review. */
+        disclosure: (m?: MatterContext) => string;
+        /** Merits / risk assessment — the real "AI outlook". */
+        risk: (m?: MatterContext) => string;
+        /** Extract deadlines / key dates with rule references. */
+        deadlines: (m?: MatterContext) => string;
+        /** Draft a document (letter / pleading / note). */
+        draft: (kind: string, m?: MatterContext) => string;
+        /** Free-form question about the matter. */
+        ask: (question: string, m?: MatterContext) => string;
+        /**
+         * Draft a clean document artifact (output IS the document — no preamble).
+         *
+         * Pure single-pass generation from the matter context: it deliberately does
+         * NOT tell the agent to look up or cite the document bundle. Asking a drafting
+         * agent to "cite the source behind each fact" sends it into a retrieval loop
+         * that can spin for minutes before emitting a token; a lawyer wants a fast
+         * first draft to refine, so we draft from the known matter facts and mark
+         * genuinely-missing specifics as [PLACEHOLDER]. (Grounded, cited analysis is
+         * what {@link brief}/{@link risk} are for.)
+         */
+        draftArtifact: (kind: string, instructions: string, m?: MatterContext) => string;
+        /**
+         * Revise a supplied passage. Returns ONLY the full revised text (no commentary),
+         * so the app can diff it against the original into a redline.
+         */
+        revise: (original: string, instruction: string, m?: MatterContext) => string;
+        /** Morning digest across the matter. */
+        digest: (m?: MatterContext) => string;
+        /** UTBMS-coded billing narrative from time context. */
+        billing: (activity: string, m?: MatterContext) => string;
+        /** Closing / lessons-learned memo. */
+        closing: (m?: MatterContext) => string;
+        /** Thought-leadership / insight article from the matter's themes. */
+        insight: (m?: MatterContext) => string;
+        /** Auto-tagging / issue classification of documents. */
+        autoTag: (m?: MatterContext) => string;
+        /** Verify uploaded onboarding documents against a KYC/CDD checklist. */
+        kyc: (clientName: string, m?: MatterContext) => string;
+        /** Triage a prospective enquiry. */
+        triage: (enquiry: string, m?: MatterContext) => string;
+        /** Conflict-of-interest style check against the workspace. */
+        conflict: (parties: string, m?: MatterContext) => string;
+        /** Capability statement / pitch letter. */
+        pitch: (opportunity: string, m?: MatterContext) => string;
+    };
+    WORKFLOW_ACTIONS: readonly [{
+        readonly id: "brief";
+        readonly title: "Matter brief";
+        readonly prompt: (m?: MatterContext) => string;
+    }, {
+        readonly id: "chronology";
+        readonly title: "Build a chronology";
+        readonly prompt: (m?: MatterContext) => string;
+    }, {
+        readonly id: "disclosure";
+        readonly title: "Review for disclosure";
+        readonly prompt: (m?: MatterContext) => string;
+    }, {
+        readonly id: "risk";
+        readonly title: "Merits & risk";
+        readonly prompt: (m?: MatterContext) => string;
+    }];
+};
+
+/**
+ * The theme-token model for the legal vertical. Firm-agnostic: the token
+ * *catalog*, default values and presets are supplied by the firm (via
+ * {@link createThemeStore}); this module owns the shared types and the logic for
+ * writing tokens onto the live document.
+ *
+ * There are two emit models, selected per-firm by {@link ThemeEmitMode}:
+ *
+ * - `'flat'` (default — Clarum): each colour key is written as an inline
+ *   `--color-<key>` custom property on `<html>`, plus `--font-*` / `--radius`.
+ *   Inline styles override the compiled `@theme` defaults, so an edit previews
+ *   live across the whole app (and the @arbidocs AI kit) and reverts cleanly.
+ *   Firms whose CSS sets `--color-*` HEX directly (Clarum) rely on this.
+ *
+ * - `'cssVars'` (the ARBI monolith): each colour key is written as a raw
+ *   HSL-triplet custom property (`--<key>: <h s l>`) into an injected
+ *   `<style id="arbi-theme-vars">` appended to `<head>`. The monolith's source
+ *   of truth is HSL triplets wrapped as `hsl(var(--x))`, with a real `.dark`
+ *   variant; writing resolved hex inline would pin the colour and defeat both
+ *   the indirection and the dark-class swap. The injected sheet is *unlayered*,
+ *   so it wins over the monolith's `@layer base` `colors.css` at equal
+ *   specificity, and a `:root { light } / :root.dark { dark }` structure keeps
+ *   the dark cascade alive.
+ */
+interface ColorToken {
+    /** Key without the `--color-` prefix, e.g. "primary" → `--color-primary`. */
+    key: string;
+    label: string;
+    /** Grouping id for the panel layout (e.g. "shadcn" | "brand" | "ai"). */
+    group: string;
+}
+interface ThemeFonts {
+    display: string;
+    sans: string;
+}
+interface ThemeTokens {
+    /** Colour values keyed by token key (hex). */
+    colors: Record<string, string>;
+    fonts: ThemeFonts;
+    /** Base radius in rem. */
+    radius: number;
+}
+interface ThemePreset {
+    id: string;
+    label: string;
+    tokens: ThemeTokens;
+}
+/** How a theme is written onto the document. See the module doc for the models. */
+type ThemeEmitMode = 'flat' | 'cssVars';
+interface ApplyThemeOptions {
+    /** Emit model. Defaults to `'flat'` (Clarum's behaviour). */
+    mode?: ThemeEmitMode;
+    /**
+     * `cssVars` mode only: dark-variant colour values keyed by token key. Emitted
+     * under `:root.dark`. When omitted, only `:root` is emitted — note that an
+     * overridden light token then also applies in dark (the injected `:root` is
+     * unlayered and beats the app's own `.dark` rules), so a firm with a dark mode
+     * MUST supply this for every editable token to keep dark mode intact.
+     */
+    dark?: Record<string, string>;
+    /** `flat` mode only: target element. Defaults to `document.documentElement`. */
+    root?: HTMLElement;
+}
+/** Id of the injected `<style>` that carries the `cssVars`-mode custom properties. */
+declare const THEME_STYLE_ID = "arbi-theme-vars";
+/**
+ * Convert a colour to the monolith's `H S% L%` HSL-triplet format.
+ *
+ * Handles `#rgb` / `#rrggbb`, `rgb()` / `rgba()`, and passes an existing triplet
+ * through untouched (so a firm can seed exact `colors.css` triplets for a
+ * byte-identical no-op). Values it cannot parse — notably `oklch(...)`, which the
+ * status tokens use — are returned unchanged so they remain usable as a raw
+ * custom-property value; converting those cleanly is out of scope.
+ */
+declare function toHslTriplet(color: string): string;
+/**
+ * Write a theme onto the live document.
+ *
+ * In `flat` mode (default) writes inline `--color-<key>` / `--font-*` / `--radius`
+ * on `document.documentElement` (or a supplied root). In `cssVars` mode writes
+ * raw HSL-triplet vars into an injected `<style#arbi-theme-vars>` (see the module
+ * doc). The legacy `applyThemeVars(theme, rootElement)` call form still works.
+ */
+declare function applyThemeVars(theme: ThemeTokens, optionsOrRoot?: ApplyThemeOptions | HTMLElement): void;
+/**
+ * Remove a theme's overrides, reverting to the stylesheet defaults.
+ *
+ * In `flat` mode removes the inline overrides for the theme's keys. In `cssVars`
+ * mode removes the injected `<style#arbi-theme-vars>` in full (restoring the
+ * app's own `colors.css` exactly).
+ */
+declare function clearThemeVars(theme: ThemeTokens, optionsOrRoot?: ApplyThemeOptions | HTMLElement): void;
+
+/**
+ * The shared theme store factory. A firm calls {@link createThemeStore} once
+ * with its token catalog, default values and presets; the returned bundle (a
+ * zustand hook + metadata) is the single source of truth consumed by every
+ * theme surface (the back-office builder panel and the studio drawer), so the
+ * token model, presets and apply logic live in exactly one place.
+ */
+
+interface ThemeState extends ThemeTokens {
+    activePresetId: string | null;
+    setColor: (key: string, value: string) => void;
+    setFont: (which: keyof ThemeFonts, value: string) => void;
+    setRadius: (radius: number) => void;
+    applyPreset: (presetId: string) => void;
+    reset: () => void;
+    /** Snapshot of the editable tokens (for export / live apply). */
+    snapshot: () => ThemeTokens;
+}
+interface ThemeStoreConfig {
+    /** The editable token catalog (keys + labels + groups). */
+    tokens: ColorToken[];
+    /** Group id → heading, for the grouped panel layout. */
+    groupLabels: Record<string, string>;
+    /** Shipped defaults (the firm's brand values). */
+    defaultTheme: ThemeTokens;
+    /** Starting points the user can apply then fine-tune. */
+    presets: ThemePreset[];
+    /** localStorage key for persistence (namespaced per firm). */
+    storageKey: string;
+    /**
+     * How edits are written onto the document. Defaults to `'flat'` (inline
+     * `--color-*`, Clarum). `'cssVars'` emits raw HSL-triplet vars into an injected
+     * `<style>` so the app's own `hsl(var(--x))` indirection + `.dark` variant
+     * survive (the ARBI monolith). See {@link applyThemeVars}.
+     */
+    mode?: ThemeEmitMode;
+    /**
+     * `cssVars` mode only: the dark-variant colour values keyed by token key,
+     * emitted under `:root.dark`. Required (per editable token) for any firm with a
+     * dark mode, otherwise a light-token override leaks into dark.
+     */
+    darkColors?: Record<string, string>;
+}
+interface ThemeBundle extends ThemeStoreConfig {
+    useStore: UseBoundStore<StoreApi<ThemeState>>;
+}
+/** Build a firm-branded theme store bundle. */
+declare function createThemeStore(config: ThemeStoreConfig): ThemeBundle;
+/** Apply a bundle's current store to the live document, honouring its emit mode. */
+declare function applyStoredTheme(bundle: ThemeBundle): void;
+
+interface ThemeEditorProps {
+    /** The firm's theme store bundle (from createThemeStore). */
+    bundle: ThemeBundle;
+    variant?: 'panel' | 'drawer';
+    /** Firm identity shown in the panel's live-preview header. */
+    preview?: {
+        title: string;
+        subtitle?: string;
+    };
+    /** Optional persistence side-channel (e.g. save theme to ARBI); returns a "via" label. */
+    onSave?: () => Promise<string | void>;
+    /** Stable testid namespace, e.g. "builder-theme" | "studio-theme". */
+    testIdPrefix?: string;
+}
+declare function ThemeEditor({ bundle, variant, preview, onSave, testIdPrefix, }: ThemeEditorProps): react.JSX.Element;
+
+/**
+ * Shared shapes for the ARBI adapter — identical in demo and live mode so UI
+ * never needs to know which backend is serving it — plus the per-firm config a
+ * firm app supplies once to wire the connection + AI layer.
+ */
+type ArbiMode = 'demo' | 'live';
+type ConnectionStatus = 'demo' | 'disconnected' | 'connecting' | 'authenticated' | 'error';
+interface ArbiUser {
+    name: string;
+    email: string;
+}
+/** A retrieval-augmented answer step surfaced from the agent loop. */
+interface AssistantStep {
+    label: string;
+    detail?: string;
+    status: 'done' | 'running' | 'queued';
+}
+interface AssistantCitation {
+    docId: string;
+    docName: string;
+    page?: number;
+    quote: string;
+}
+interface AssistantMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    steps?: AssistantStep[];
+    citations?: AssistantCitation[];
+    streaming?: boolean;
+}
+/**
+ * Everything firm-specific about the ARBI wiring, injected once at the app root.
+ * Framework-agnostic on purpose: the app reads its own env (Vite, Next, …) and
+ * passes the resolved values in, so the package never touches `import.meta.env`.
+ */
+interface FirmArbiConfig {
+    /** Live backend URL. Empty string ⇒ run entirely in seeded demo mode. */
+    apiUrl: string;
+    /** Inert URL used to mount the SDK provider when there's no live backend. */
+    demoApiUrl?: string;
+    /** Preferred live workspace ext_id (else the first workspace is used). */
+    workspaceId?: string;
+    /** Default assistant *configuration* ext_id every agentic run is grounded on. */
+    assistantConfig?: string;
+    /** The seeded demo identity shown when running without a backend. */
+    demoUser: ArbiUser;
+    /** Workspace id used in demo mode (default "demo-firm"). */
+    demoWorkspaceId?: string;
+}
+
+interface ConnectionValue {
+    mode: ArbiMode;
+    status: ConnectionStatus;
+    user: ArbiUser | null;
+    workspaceId: string | null;
+    apiConfigured: boolean;
+    apiUrl: string;
+    error: string | null;
+    /** Default assistant config ext_id (for the AI hooks). */
+    assistantConfig?: string;
+    /** Fallback workspace ext_id when none is actively selected. */
+    fallbackWorkspaceId?: string;
+    /** Authenticate. Live login when a backend is configured, otherwise the demo firm. */
+    login: (email: string, password: string) => Promise<void>;
+    /** One-click demo entry (no backend required). */
+    enterDemo: () => void;
+    logout: () => void;
+    setWorkspace: (id: string) => void;
+}
+declare function ConnectionProvider({ config, children, }: {
+    config: FirmArbiConfig;
+    children: ReactNode;
+}): react.JSX.Element;
+declare function useConnection(): ConnectionValue;
+declare const isAuthenticated: (s: ConnectionStatus) => s is "demo" | "authenticated";
+
+declare function LegalArbiProvider({ config, children, }: {
+    config: FirmArbiConfig;
+    children: ReactNode;
+}): react.JSX.Element;
+
+/**
+ * The kit's `useAiTask` with the firm's default assistant configuration
+ * injected, so call sites needn't know the config ext_id.
+ */
+declare function useFirmAiTask(): {
+    run: (question: string, docIds: string[], opts?: AiRunOptions) => Promise<_arbidocs_react.SSEStreamResult | null>;
+    status: _arbidocs_react.AiTaskStatus;
+    text: string;
+    stepCount: number;
+    error: string | null;
+    responseId: string | null;
+    artifacts: {
+        t?: number | null;
+        type: "arbi.artifact";
+        doc_ext_id: string;
+        title: string;
+        mode: "markdown" | "html" | "text" | "image";
+        content: string;
+        file_type: string;
+        is_complete: boolean;
+        version: number;
+        message_ext_id?: string | null;
+    }[];
+    reset: () => void;
+    isRunning: boolean;
+    isDone: boolean;
+};
+/** Resolve the active workspace + its document ids (what we ground the agent on). */
+declare function useWorkspaceDocs(): {
+    wsId: string | undefined;
+    docs: {
+        external_id: string;
+        workspace_ext_id: string;
+        file_name?: string | null | undefined;
+        status?: string | null | undefined;
+        error_message?: string | null | undefined;
+        failed_stage?: string | null | undefined;
+        n_pages?: number | null | undefined;
+        n_chunks?: number | null | undefined;
+        tokens?: number | null | undefined;
+        file_type?: string | null | undefined;
+        file_size?: number | null | undefined;
+        storage_type?: string | null | undefined;
+        storage_uri?: string | null | undefined;
+        content_hash?: string | null | undefined;
+        shared?: boolean | null | undefined;
+        re_ocred?: boolean | null | undefined;
+        config_ext_id?: string | null | undefined;
+        parent_ext_id?: string | null | undefined;
+        created_by_ext_id: string;
+        updated_by_ext_id?: string | null | undefined;
+        created_at: string;
+        updated_at: string;
+        wp_type?: string | null | undefined;
+        folder?: string | null | undefined;
+        doctags: {
+            doc_ext_id: string;
+            tag_ext_id: string;
+            note?: string | null | undefined;
+            citations?: {
+                [x: string]: {
+                    chunk_ids: string[];
+                    scores: number[];
+                    statement: string;
+                    offset_start: number;
+                    offset_end: number;
+                };
+            } | null | undefined;
+            created_by_ext_id: string;
+            updated_by_ext_id?: string | null | undefined;
+            created_at: string;
+            updated_at: string;
+        }[];
+        doc_metadata?: {
+            doc_nature?: string | null | undefined;
+            doc_author?: string | null | undefined;
+            doc_subject?: string | null | undefined;
+            doc_date?: string | null | undefined;
+            title?: string | null | undefined;
+        } | null | undefined;
+    }[];
+    docIds: string[];
+    isLoading: boolean;
+    isError: boolean;
+    ready: boolean;
+};
+/** Search the active workspace's documents and return the top matching passages. */
+declare function useSemanticSearch(): {
+    query: string;
+    results: _arbidocs_react.SearchChunk[];
+    status: _arbidocs_react.AiTaskStatus;
+    error: string | null;
+    search: (q: string, mode?: "semantic" | "keyword" | "hybrid") => Promise<void>;
+    isRunning: boolean;
+};
+
+/**
+ * Compose a stable, kebab-case data-testid from parts.
+ * Convention: {area}-{element}[-{qualifier}...]
+ *   tid("matters", "row", "CLM-2026-0042") -> "matters-row-clm-2026-0042"
+ * Keeps Playwright selectors predictable across a firm app.
+ */
+declare function tid(...parts: Array<string | number | undefined | false>): string;
+
+/**
+ * Firm-app formatting helpers — currency, initials, dates, durations and
+ * percentages. UK-oriented defaults (en-GB / GBP / "d MMM yyyy") suit an English
+ * law firm; nothing here is firm-branded, so every firm app shares them.
+ *
+ * Dependency-free on purpose (uses the platform `Intl` APIs) so the package
+ * stays light and needs no date library.
+ */
+/** Format a number as GBP, e.g. £1,240,000 or £12.4k depending on `compact`. */
+declare function gbp(value: number, compact?: boolean): string;
+/** Initials from a person's name, e.g. "Amara N. Okafor" -> "AO". */
+declare function initials(name: string): string;
+/** "12 Mar 2026" */
+declare function fmtDate(iso: string): string;
+/** "12 Mar 2026, 14:30" */
+declare function fmtDateTime(iso: string): string;
+/** "3 days ago" / "in 2 hours" — largest whole unit, like date-fns strict. */
+declare function fromNow(iso: string, from?: Date): string;
+/** Signed day count to a date from a reference day. Negative = overdue. */
+declare function daysUntil(iso: string, from?: Date): number;
+/** Compact hours, e.g. 12.5h */
+declare function hrs(n: number): string;
+/** Percentage with no decimals, e.g. 82% */
+declare function pct(n: number): string;
+
+interface Column<T> {
+    key: string;
+    header: ReactNode;
+    render: (row: T) => ReactNode;
+    align?: 'left' | 'right' | 'center';
+    className?: string;
+    headClassName?: string;
+}
+interface DataTableProps<T> {
+    columns: Column<T>[];
+    rows: T[];
+    getRowId: (row: T) => string;
+    onRowClick?: (row: T) => void;
+    /** testid area prefix, e.g. "matters" -> rows get "matters-row-{id}" */
+    area: string;
+    emptyTitle?: string;
+    emptyDescription?: string;
+    className?: string;
+}
+/** The one true table. Column-config driven, fully test-id'd, optional row navigation. */
+declare function DataTable<T>({ columns, rows, getRowId, onRowClick, area, emptyTitle, emptyDescription, className, }: DataTableProps<T>): react.JSX.Element;
+
+interface DataTableBlockColumn {
+    /** Column heading text. */
+    header: string;
+    /** Key used to look a cell up in each row record. */
+    field: string;
+    /** Cell/heading alignment. */
+    align?: 'left' | 'right' | 'center';
+}
+interface DataTableBlockProps {
+    /** Serializable column schema. */
+    columns: DataTableBlockColumn[];
+    /** One record per row; cells are looked up by each column's `field`. */
+    rows: Array<Record<string, string>>;
+    /** Optional caption rendered above the table. */
+    caption?: string;
+    /** Empty-state title shown when there are no rows. */
+    emptyText?: string;
+    /** testid area prefix; also set on the wrapper element. */
+    testId?: string;
+}
+/**
+ * Renders a {@link DataTable} from a flat, serializable schema. Columns are mapped
+ * to `Column<TableRowData>[]` (header string, positional-stable key, alignment) and
+ * each cell is resolved by `field`; rows carry a synthetic id for React keys/testids.
+ */
+declare function DataTableBlock({ columns, rows, caption, emptyText, testId }: DataTableBlockProps): react.JSX.Element;
+
+/**
+ * GridView — a flexible AG Grid presentational core.
+ *
+ * Pure and app-agnostic: it owns no global state and pulls in no store. Column
+ * state persistence (order / width / visibility / sort / filter) is exposed as a
+ * controlled/uncontrolled prop pair — `gridState` (initial state, read once at
+ * mount) and `onGridStateChange` (called whenever AG Grid's state changes). An
+ * app wires those to wherever it keeps the state (Zustand, localStorage, a URL,
+ * a server) via a thin adapter; the core stays decoupled.
+ *
+ * Themed entirely via CSS variables (see the sibling `grid.css`, which a
+ * consuming app imports globally), so it inherits the host's light/dark theme.
+ */
+
+interface GridViewSelection<T> {
+    mode: 'single' | 'multiple';
+    selected: T[];
+    onSelectionChange: (items: T[]) => void;
+}
+interface GridViewEmptyState {
+    icon?: react__default.ReactNode;
+    title?: string;
+    message?: string;
+    action?: react__default.ReactNode;
+}
+interface GridViewProps<T> {
+    items: T[];
+    columnDefs: ColDef<T>[];
+    getItemId: (item: T) => string;
+    selection?: GridViewSelection<T>;
+    emptyState?: GridViewEmptyState;
+    isLoading?: boolean;
+    loadingMessage?: string;
+    gridOptions?: Partial<GridOptions<T>>;
+    onGridReady?: (params: {
+        api: GridApi<T>;
+    }) => void;
+    onCellValueChanged?: (event: CellValueChangedEvent<T>) => void;
+    onRowClick?: (item: T) => void;
+    persistState?: boolean;
+    gridId?: string;
+    gridState?: GridState;
+    onGridStateChange?: (state: GridState) => void;
+    initialVisibleColumns?: string[];
+    className?: string;
+    height?: string | number;
+    rowHeight?: number;
+    testId?: string;
+    pinnedBottomRowData?: T[];
+    pinnedTopRowData?: T[];
+    pagination?: boolean;
+    paginationPageSizeSelector?: number[];
+    showEmpty?: boolean;
+}
+declare function GridView<T>({ items, columnDefs, getItemId, selection, emptyState, isLoading, loadingMessage, gridOptions, onGridReady, onCellValueChanged, onRowClick, persistState, gridState, onGridStateChange, initialVisibleColumns, className, height, rowHeight, testId, pinnedBottomRowData, pinnedTopRowData, pagination, paginationPageSizeSelector, showEmpty, }: GridViewProps<T>): react__default.JSX.Element;
+
+/** Centered placeholder for empty lists/panels: icon + title + description + action. */
+declare function EmptyState({ icon: Icon, title, description, action, className, testId, }: {
+    icon?: LucideIcon;
+    title: string;
+    description?: string;
+    action?: ReactNode;
+    className?: string;
+    testId?: string;
+}): react.JSX.Element;
+
+/** Standard back-office page title block: eyebrow + title + description + actions. */
+declare function PageHeader({ title, eyebrow, description, actions, className, testId, }: {
+    title: string;
+    eyebrow?: string;
+    description?: string;
+    actions?: ReactNode;
+    className?: string;
+    testId?: string;
+}): react.JSX.Element;
+
+/** Editorial heading block for marketing sections: eyebrow + title + lead. */
+declare function SectionHeading({ eyebrow, title, lead, align, className, invert, }: {
+    eyebrow?: string;
+    title: string;
+    lead?: string;
+    align?: 'left' | 'center';
+    className?: string;
+    invert?: boolean;
+}): react.JSX.Element;
+
+/** Search + filter bar used above every list view. */
+declare function Toolbar({ search, onSearch, searchPlaceholder, filters, actions, className, testId, }: {
+    search?: string;
+    onSearch?: (v: string) => void;
+    searchPlaceholder?: string;
+    filters?: ReactNode;
+    actions?: ReactNode;
+    className?: string;
+    testId?: string;
+}): react.JSX.Element;
+
+interface MetricCardProps {
+    label: string;
+    value: string | number;
+    icon?: LucideIcon;
+    hint?: string;
+    delta?: {
+        value: string;
+        direction: 'up' | 'down';
+        good?: boolean;
+    };
+    /** Icon accent, keyed to the firm's brand token contract. */
+    accent?: 'ink' | 'emerald' | 'brass';
+    testId?: string;
+}
+/** The one true KPI tile. Used across every dashboard and module header. */
+declare function MetricCard({ label, value, icon: Icon, hint, delta, accent, testId, }: MetricCardProps): react.JSX.Element;
+
+type BlockImageAspect = '16:9' | '4:3' | '1:1' | '21:9' | '4:5';
+type BlockImageRounded = 'none' | 'md' | 'lg' | 'full';
+interface BlockImageProps {
+    src?: string;
+    alt?: string;
+    aspect?: BlockImageAspect;
+    rounded?: BlockImageRounded;
+    className?: string;
+    testId?: string;
+}
+/**
+ * Image with a graceful, self-contained fallback: when `src` is empty it renders a
+ * token-clean gradient placeholder (no network needed) so the palette always looks
+ * good in the editor and in demos. Token-only classes so it themes per firm.
+ */
+declare function BlockImage({ src, alt, aspect, rounded, className, testId, }: BlockImageProps): react.JSX.Element;
+
+type HeroTone = 'default' | 'muted' | 'ink';
+type HeroAlign = 'left' | 'center';
+interface HeroCta {
+    label?: string;
+    href?: string;
+}
+interface HeroProps {
+    eyebrow?: string;
+    title: string;
+    subtitle?: string;
+    primaryCta?: HeroCta;
+    secondaryCta?: HeroCta;
+    align?: HeroAlign;
+    tone?: HeroTone;
+    imageUrl?: string;
+    testId?: string;
+}
+/** Editorial marketing hero: eyebrow, headline, subtitle, two CTAs and a visual. */
+declare function Hero({ eyebrow, title, subtitle, primaryCta, secondaryCta, align, tone, imageUrl, testId, }: HeroProps): react.JSX.Element;
+
+interface FeatureItem {
+    icon?: LucideIcon;
+    title: string;
+    description?: string;
+}
+interface FeatureGridProps {
+    columns?: '2' | '3';
+    items: FeatureItem[];
+    testId?: string;
+}
+/** Responsive grid of icon + title + description feature cards. */
+declare function FeatureGrid({ columns, items, testId }: FeatureGridProps): react.JSX.Element;
+
+interface StatItem {
+    value: string;
+    label: string;
+}
+interface StatGroupProps {
+    items: StatItem[];
+    testId?: string;
+}
+/** Big-number stat group — headline metrics with captions. */
+declare function StatGroup({ items, testId }: StatGroupProps): react.JSX.Element;
+
+interface TestimonialProps {
+    quote: string;
+    author?: string;
+    role?: string;
+    avatarUrl?: string;
+    testId?: string;
+}
+/** A single pull-quote testimonial with an author and optional avatar. */
+declare function Testimonial({ quote, author, role, avatarUrl, testId }: TestimonialProps): react.JSX.Element;
+
+type CTABannerTone = 'default' | 'muted' | 'ink';
+interface CTABannerProps {
+    title: string;
+    subtitle?: string;
+    cta?: {
+        label?: string;
+        href?: string;
+    };
+    tone?: CTABannerTone;
+    testId?: string;
+}
+/** Full-width call-to-action banner. */
+declare function CTABanner({ title, subtitle, cta, tone, testId }: CTABannerProps): react.JSX.Element;
+
+interface LogoItem {
+    label: string;
+}
+interface LogoCloudProps {
+    items: LogoItem[];
+    testId?: string;
+}
+/**
+ * Text-based "logo" wall — brand names rendered as muted pill marks. Self-contained
+ * (no external images) so the palette looks complete offline.
+ */
+declare function LogoCloud({ items, testId }: LogoCloudProps): react.JSX.Element;
+
+interface FaqItem {
+    question: string;
+    answer?: string;
+}
+interface FAQProps {
+    items: FaqItem[];
+    testId?: string;
+}
+/**
+ * Accessible disclosure list. Built on native `<details>`/`<summary>` so it works
+ * without client state (correct in the Puck preview and static renders) and stays
+ * keyboard-accessible. Token-only styling.
+ */
+declare function FAQ({ items, testId }: FAQProps): react.JSX.Element;
+
+interface RichTextBlockProps {
+    content: string;
+    testId?: string;
+}
+/**
+ * Prose block. Reuses the shared markdown renderer (`AiMarkdown`) so long-form copy
+ * gets the one house style for headings, lists, tables and emphasis — token-clean
+ * and themeable per firm.
+ */
+declare function RichTextBlock({ content, testId }: RichTextBlockProps): react.JSX.Element;
+
+type CalloutVariant = 'info' | 'success' | 'warning' | 'danger';
+interface CalloutProps {
+    variant?: CalloutVariant;
+    title?: string;
+    body?: string;
+    testId?: string;
+}
+/** Inline notice box in one of four semantic tones. */
+declare function Callout({ variant, title, body, testId }: CalloutProps): react.JSX.Element;
+
+type AvatarBlockSize = 'sm' | 'md' | 'lg' | 'xl';
+interface AvatarBlockProps {
+    src?: string;
+    name?: string;
+    size?: AvatarBlockSize;
+    testId?: string;
+}
+/** Avatar with an initials fallback when no image is supplied. */
+declare function AvatarBlock({ src, name, size, testId }: AvatarBlockProps): react.JSX.Element;
+
+interface NavLink {
+    label: string;
+    href?: string;
+}
+interface NavbarProps {
+    brand: string;
+    links: NavLink[];
+    cta?: {
+        label?: string;
+        href?: string;
+    };
+    testId?: string;
+}
+/** Marketing top navigation: brand, inline links and an optional CTA button. */
+declare function Navbar({ brand, links, cta, testId }: NavbarProps): react.JSX.Element;
+
+interface FooterLink {
+    label: string;
+    href?: string;
+}
+interface FooterColumn {
+    heading: string;
+    links: FooterLink[];
+}
+interface FooterProps {
+    columns: FooterColumn[];
+    copyright?: string;
+    testId?: string;
+}
+/** Site footer: a row of link columns plus a copyright line. */
+declare function Footer({ columns, copyright, testId }: FooterProps): react.JSX.Element;
+
+interface ListItem {
+    text: string;
+}
+interface ListBlockProps {
+    ordered?: boolean;
+    items: ListItem[];
+    testId?: string;
+}
+/** Ordered or unordered prose list. Token-clean. */
+declare function ListBlock({ ordered, items, testId }: ListBlockProps): react.JSX.Element;
+
+type ColumnsCount = 2 | 3 | 4;
+type ColumnsGap = 'sm' | 'md' | 'lg';
+interface ColumnsProps {
+    count?: ColumnsCount;
+    gap?: ColumnsGap;
+    columns: ReactNode[];
+    testId?: string;
+}
+/** Responsive N-column row. Each column hosts a nested Puck slot. */
+declare function Columns({ count, gap, columns, testId }: ColumnsProps): react.JSX.Element;
+
+type SpacerSize = 'sm' | 'md' | 'lg' | 'xl';
+interface SpacerProps {
+    size?: SpacerSize;
+    testId?: string;
+}
+/** Vertical whitespace. */
+declare function Spacer({ size, testId }: SpacerProps): react.JSX.Element;
+
+type ContainerWidth = 'narrow' | 'default' | 'wide' | 'full';
+type ContainerPadding = 'none' | 'sm' | 'md' | 'lg';
+interface ContainerProps {
+    width?: ContainerWidth;
+    padding?: ContainerPadding;
+    children: ReactNode;
+    testId?: string;
+}
+/** Max-width wrapper that centres and pads a nested Puck slot. */
+declare function Container({ width, padding, children, testId }: ContainerProps): react.JSX.Element;
+
+/**
+ * Navigation shapes shared by firm app shells. The concrete nav manifest (which
+ * modules, in what order) is per-firm data the app supplies; these interfaces
+ * give it a typed contract the shared shell can render.
+ */
+
+interface AppNavItem {
+    to: string;
+    label: string;
+    icon: LucideIcon;
+    id: string;
+    /** true for ARBI-powered modules (document management + agentic AI). */
+    arbi?: boolean;
+    end?: boolean;
+}
+interface AppNavSection {
+    heading: string;
+    items: AppNavItem[];
+}
+
+/**
+ * Shared studio types — the persistence contract, page metadata and the AI
+ * prompt-builder signature the firm supplies. Firm-agnostic: a firm app wires
+ * these to its own marketing workspace and voice.
+ */
+
+/** The Arbi instance type, borrowed from the hook so we don't import internals. */
+type Arbi = ReturnType<typeof useArbi>;
+/** A page the studio can author (slug → friendly label). */
+interface StudioPageMeta {
+    slug: string;
+    label: string;
+}
+/** Where a save/load ultimately resolved. */
+type PersistVia = 'arbi' | 'local';
+interface LoadResult<T> {
+    data: T | null;
+    via: PersistVia;
+}
+/** The save/load surface the studio + renderer consume. */
+interface StudioPersistence {
+    savePage: (arbi: Arbi | null, live: boolean, slug: string, data: unknown) => Promise<PersistVia>;
+    loadPage: <T>(arbi: Arbi | null, live: boolean, slug: string) => Promise<LoadResult<T>>;
+    saveTheme: (arbi: Arbi | null, live: boolean, theme: unknown) => Promise<PersistVia>;
+    loadTheme: <T>(arbi: Arbi | null, live: boolean) => Promise<LoadResult<T>>;
+}
+/** Build an AI instruction for a field, given its kind, label and current text. */
+type BuildPrompt = (a: {
+    kind: string;
+    label: string;
+    current: string;
+}) => string;
+
+interface StudioEditorProps {
+    config: Config;
+    pages: readonly StudioPageMeta[];
+    persistence: StudioPersistence;
+    themeBundle: ThemeBundle;
+    defaultTheme: ThemeTokens;
+    brandLabel: string;
+    backHref?: string;
+    backLabel?: string;
+    live: boolean;
+    initialSlug?: string;
+    testIdPrefix?: string;
+}
+declare function StudioEditor({ config, pages, persistence, themeBundle, defaultTheme, brandLabel, backHref, backLabel, live, initialSlug, testIdPrefix, }: StudioEditorProps): react.JSX.Element;
+
+interface PageRendererProps {
+    config: Config;
+    persistence: StudioPersistence;
+    defaultTheme: ThemeTokens;
+    live: boolean;
+    slug?: string;
+    emptyState?: {
+        title: string;
+        body: string;
+    };
+    testIdPrefix?: string;
+}
+declare function PageRenderer({ config, persistence, defaultTheme, live, slug: slugProp, emptyState, testIdPrefix, }: PageRendererProps): react.JSX.Element;
+
+interface StudioPersistenceConfig {
+    /** The public marketing workspace that backs the site builder. */
+    workspaceId: string;
+    /** Folder inside the workspace where studio artefacts live. */
+    folder?: string;
+    /** Prefix for the localStorage mirror keys (e.g. "clarum-studio-"). */
+    storagePrefix: string;
+    /** localStorage key for the theme mirror (default `${storagePrefix}theme`). */
+    themeStorageKey?: string;
+    /** File name for the persisted theme document (default "theme.json"). */
+    themeFileName?: string;
+    /** File name for a page's persisted document (default `${slug}.json`). */
+    pageFileName?: (slug: string) => string;
+}
+declare function createStudioPersistence(cfg: StudioPersistenceConfig): StudioPersistence;
+
+interface AiFieldsConfig {
+    /** The marketing workspace the AI grounds on. */
+    workspaceId: string;
+    /** Turns a field's kind/label/current text into an instruction. */
+    buildPrompt: BuildPrompt;
+    /** Default prompt kind when a field does not specify one. */
+    defaultKind?: string;
+    /** Testid namespace for the field + write button. */
+    testIdPrefix?: string;
+}
+interface AiFields {
+    aiText: (label: string, placeholder?: string) => CustomField<string>;
+    aiTextarea: (label: string, placeholder?: string, kind?: string) => CustomField<string>;
+}
+declare function createAiFields(cfg: AiFieldsConfig): AiFields;
+
+interface SectionProps {
+    children: ReactNode;
+    tone?: 'default' | 'muted' | 'ink';
+    className?: string;
+}
+declare function Section({ children, tone, className }: SectionProps): react.JSX.Element;
+
+/**
+ * Shared field helpers for the block registry. Every block config — the built-ins
+ * in {@link createArbiBlocksConfig} and the website blocks in
+ * {@link file://./websiteBlocks.tsx} — builds its Puck fields from this one kit so
+ * the AI-or-plain copy fallback, the icon `select`, the tone/bool radios and the
+ * stable render-time testid are declared once.
+ */
+
+declare const iconMap: Record<string, LucideIcon>;
+/** The bundle of field helpers a block config needs. */
+interface BlockKit {
+    /** Single-line copy: AI-authorable when a firm supplies aiFields, else plain text. */
+    textField: (label: string, placeholder?: string) => Field;
+    /** Multi-line copy: AI-authorable when a firm supplies aiFields, else plain textarea. */
+    textareaField: (label: string, placeholder?: string, kind?: string) => Field;
+    /** A Yes/No radio. */
+    boolRadio: (label: string) => Field;
+    /** A `select` over {@link iconMap} names. */
+    iconField: (label?: string) => Field;
+    /** Resolve an icon name to its Lucide component. */
+    resolveIcon: (name?: string) => LucideIcon | undefined;
+    /** Stable, e2e-locatable testid derived from a block's Puck id. */
+    blockTestId: (id: string) => string;
+}
+/** Build the shared field helpers, closing over the firm's optional AI fields. */
+declare function createBlockKit(ai?: AiFields): BlockKit;
+
+interface ArbiBlocksConfigOptions {
+    /**
+     * Firm AI fields from {@link createAiFields}. When present, every string copy
+     * prop becomes an AI-authorable field; when absent, plain Puck text inputs.
+     */
+    aiFields?: AiFields;
+}
+
+declare function createArbiBlocksConfig(opts?: ArbiBlocksConfigOptions): Config;
+
+/** Build every website block, closing over the shared field {@link BlockKit}. */
+declare function createWebsiteBlocks(kit: BlockKit): Record<string, ComponentConfig>;
+
+/**
+ * Module registry types — a typed model of a firm's back-office modules,
+ * derived from its canonical nav. The builder toggles/reorders these; the
+ * sidebar consumes the resolved result. Firm-agnostic: the nav manifest is
+ * supplied to {@link createModuleRegistry}.
+ */
+
+interface BuilderModule {
+    id: string;
+    label: string;
+    /** Section heading it belongs to (Practice / Knowledge & AI / …). */
+    section: string;
+    icon: LucideIcon;
+    to: string;
+    arbi: boolean;
+    end: boolean;
+    /** Original position — global index across all sections. */
+    defaultOrder: number;
+}
+interface ResolvedModule extends BuilderModule {
+    enabled: boolean;
+    order: number;
+}
+interface ModuleRegistry {
+    DEFAULT_MODULES: BuilderModule[];
+    SECTION_ORDER: string[];
+    toNavItem: (m: BuilderModule) => AppNavItem;
+}
+
+/**
+ * Module registry — a typed model of the back-office modules derived from a
+ * firm's canonical nav. We read the nav rather than re-declaring it so the
+ * registry can never drift from the shipped nav (DRY). The builder
+ * toggles/reorders these; the sidebar can consume the result via the module
+ * store's `useEnabledNav()` without any nav data being duplicated here.
+ */
+
+/** Build a registry from a firm's nav manifest. */
+declare function createModuleRegistry(appNav: AppNavSection[]): ModuleRegistry;
+
+interface ModuleOverride {
+    enabled: boolean;
+    /** Effective order within the section. */
+    order: number;
+}
+interface ModuleStore {
+    /** Sparse overrides keyed by module id; absent → registry default. */
+    overrides: Record<string, ModuleOverride>;
+    toggle: (id: string) => void;
+    /** Move a module up/down among its enabled+disabled section siblings. */
+    move: (id: string, dir: 'up' | 'down') => void;
+    reset: () => void;
+}
+interface ModuleStoreBundle {
+    useModuleStore: UseBoundStore<StoreApi<ModuleStore>>;
+    useResolvedModules: () => {
+        section: string;
+        modules: ResolvedModule[];
+    }[];
+    useEnabledNav: () => AppNavSection[];
+}
+declare function createModuleStore({ registry, storageKey, }: {
+    registry: ModuleRegistry;
+    storageKey: string;
+}): ModuleStoreBundle;
+
+/**
+ * Agent-selection store — which ARBI behaviour configurations and agents the
+ * firm marks "active" for this vertical. Pure selection state (the configs and
+ * agents themselves come live from ARBI via React Query), persisted so the
+ * choice seeds the exported vertical config.
+ *
+ * Firm-agnostic: {@link createAgentSelectionStore} parameterises the persist key.
+ */
+
+interface AgentSelectionStore {
+    /** Configuration ext_ids marked active. */
+    configIds: string[];
+    /** Agent ext_ids marked active. */
+    agentIds: string[];
+    toggleConfig: (id: string) => void;
+    toggleAgent: (id: string) => void;
+    clear: () => void;
+}
+declare function createAgentSelectionStore({ storageKey, }: {
+    storageKey: string;
+}): UseBoundStore<StoreApi<AgentSelectionStore>>;
+
+/**
+ * Vertical-config export shapes — the JSON seed a generator consumes to stamp
+ * out a new vertical app (theme + enabled/ordered modules + selected agents).
+ */
+
+interface ExportedModule {
+    id: string;
+    label: string;
+    section: string;
+    to: string;
+    arbi: boolean;
+    enabled: boolean;
+    order: number;
+}
+interface VerticalConfig {
+    version: 1;
+    generatedAt: string;
+    vertical: {
+        name: string;
+        key: string;
+    };
+    theme: ThemeTokens;
+    modules: ExportedModule[];
+    agents: {
+        configIds: string[];
+        agentIds: string[];
+    };
+}
+
+/**
+ * Vertical-config export — combine the configured theme, enabled/ordered
+ * modules and selected ARBI agent configs into one JSON document. This is the
+ * seed a generator would consume to stamp out a new vertical app.
+ *
+ * Firm-agnostic: {@link createVerticalExport} closes over the theme/module/agent
+ * stores and the module registry.
+ */
+
+interface VerticalExportConfig {
+    vertical: {
+        name: string;
+        key: string;
+    };
+    themeStore: UseBoundStore<StoreApi<ThemeState>>;
+    moduleStore: ModuleStoreBundle;
+    agentStore: UseBoundStore<StoreApi<AgentSelectionStore>>;
+    registry: ModuleRegistry;
+}
+interface VerticalExport {
+    buildVerticalConfig: () => VerticalConfig;
+    serialize: (cfg?: VerticalConfig) => string;
+    download: (cfg?: VerticalConfig) => void;
+}
+declare function createVerticalExport(cfg: VerticalExportConfig): VerticalExport;
+
+type AgentStore$1 = UseBoundStore<StoreApi<AgentSelectionStore>>;
+interface VerticalBuilderProps {
+    themeBundle: ThemeBundle;
+    moduleStore: ModuleStoreBundle;
+    agentStore: AgentStore$1;
+    exporter: VerticalExport;
+    themePreview: {
+        title: string;
+        subtitle?: string;
+    };
+    header?: ReactNode;
+    studioHref?: string;
+    testIdPrefix?: string;
+}
+declare function VerticalBuilder({ themeBundle, moduleStore, agentStore, exporter, themePreview, header, testIdPrefix, }: VerticalBuilderProps): react.JSX.Element;
+
+interface ModuleManagerProps {
+    store: ModuleStoreBundle;
+    testIdPrefix?: string;
+}
+declare function ModuleManager({ store, testIdPrefix }: ModuleManagerProps): react.JSX.Element;
+
+type AgentStore = UseBoundStore<StoreApi<AgentSelectionStore>>;
+interface AgentsPanelProps {
+    store: AgentStore;
+    testIdPrefix?: string;
+}
+declare function AgentsPanel({ store, testIdPrefix }: AgentsPanelProps): react.JSX.Element;
+
+export { type AgentSelectionStore, AgentsPanel, type AgentsPanelProps, type AiFields, type AiFieldsConfig, type AppNavItem, type AppNavSection, type ApplyThemeOptions, type ArbiBlocksConfigOptions, type ArbiMode, type ArbiUser, type AssistantCitation, type AssistantMessage, type AssistantStep, AvatarBlock, type AvatarBlockProps, BlockImage, type BlockImageProps, type BlockKit, type BuildPrompt, type BuilderModule, CTABanner, type CTABannerProps, Callout, type CalloutProps, type CalloutVariant, type ColorToken, type Column, Columns, type ColumnsProps, ConnectionProvider, type ConnectionStatus, Container, type ContainerProps, DataTable, DataTableBlock, type DataTableBlockColumn, type DataTableBlockProps, EmptyState, type ExportedModule, FAQ, type FAQProps, type FaqItem, FeatureGrid, type FeatureGridProps, type FeatureItem, type FirmArbiConfig, Footer, type FooterColumn, type FooterLink, type FooterProps, GridView, type GridViewEmptyState, type GridViewProps, type GridViewSelection, Hero, type HeroCta, type HeroProps, LegalArbiProvider, ListBlock, type ListBlockProps, type ListItem, type LoadResult, LogoCloud, type LogoCloudProps, type LogoItem, type MatterContext, MetricCard, type MetricCardProps, ModuleManager, type ModuleManagerProps, type ModuleRegistry, type ModuleStoreBundle, type NavLink, Navbar, type NavbarProps, PageHeader, PageRenderer, type PageRendererProps, type PersistVia, type PromptConfig, type PromptLibrary, type Prompts, type ResolvedModule, RichTextBlock, type RichTextBlockProps, Section, SectionHeading, type SectionProps, Spacer, type SpacerProps, StatGroup, type StatGroupProps, type StatItem, StudioEditor, type StudioEditorProps, type StudioPageMeta, type StudioPersistence, type StudioPersistenceConfig, THEME_STYLE_ID, Testimonial, type TestimonialProps, type ThemeBundle, ThemeEditor, type ThemeEditorProps, type ThemeEmitMode, type ThemeFonts, type ThemePreset, type ThemeState, type ThemeStoreConfig, type ThemeTokens, Toolbar, VerticalBuilder, type VerticalBuilderProps, type VerticalConfig, type VerticalExport, type VerticalExportConfig, applyStoredTheme, applyThemeVars, clearThemeVars, createAgentSelectionStore, createAiFields, createArbiBlocksConfig, createBlockKit, createModuleRegistry, createModuleStore, createPromptLibrary, createStudioPersistence, createThemeStore, createVerticalExport, createWebsiteBlocks, daysUntil, fmtDate, fmtDateTime, fromNow, gbp, hrs, iconMap, initials, isAuthenticated, matterToContext, pct, tid, toHslTriplet, useConnection, useFirmAiTask, useSemanticSearch, useWorkspaceDocs };