@nivaro/react 0.1.66 → 0.1.68

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { CascadeFilterRule } from '@nivaro/sdk';
 import { default as default_2 } from 'react';
 import { FieldDependencyConfig } from '@nivaro/sdk';
-import type { ImportParseResponse } from '@nivaro/sdk';
+import { ImportParseResponse } from '@nivaro/sdk';
+import { ImportTemplateSummary } from '@nivaro/sdk';
 import { JSX } from 'react';
 import { JSXElementConstructor } from 'react';
 import { NivaroClient } from '@nivaro/sdk';
@@ -15,6 +16,56 @@ import { ReportQueryWidgetConfig } from '@nivaro/sdk';
 import { UseMutationResult } from '@tanstack/react-query';
 import { UserScopesInfo } from '@nivaro/sdk';
 
+export declare function AccessDeniedPanel({ collection, itemId, onBack }: {
+    collection: string;
+    itemId: string;
+    /** Host-provided back action (e.g. navigate(-1)); renders a button when set. */
+    onBack?: () => void;
+}): JSX.Element;
+
+/**
+ * Options filter for every nivaro_users picker: mirrors listUsers() — redacted
+ * accounts never appear, and suspended users cannot be PICKED (existing values
+ * still display, since current-value lookups fetch by id with no filter).
+ * Null-safe on status so a fresh install with unset statuses keeps working.
+ */
+export declare const ACTIVE_USER_OPTION_FILTER: {
+    _and: ({
+        is_redacted: {
+            _eq: boolean;
+        };
+        _or?: undefined;
+    } | {
+        _or: ({
+            status: {
+                _neq: string;
+                _null?: undefined;
+            };
+        } | {
+            status: {
+                _null: boolean;
+                _neq?: undefined;
+            };
+        })[];
+        is_redacted?: undefined;
+    })[];
+};
+
+export declare function AddendumPanel({ collection, item, addendumLayoutId, canCreate, onActiveCountChange, onApplied, defaultExpanded, }: {
+    collection: string;
+    item: string;
+    addendumLayoutId?: number | null;
+    canCreate?: boolean;
+    onActiveCountChange?: (count: number) => void;
+    /** Fired after an addendum is approved/rejected/submitted — i.e. whenever the
+     *  parent record may now read differently. ItemEditForm uses it to refresh a
+     *  generated PDF so the attached document matches the amended record. */
+    onApplied?: () => void;
+    defaultExpanded?: boolean;
+}): JSX.Element | null;
+
+export declare function agingBucket(hours: number | null): string;
+
 export declare function AlertManagerView({ defaultTab, hiddenTabs, onOpenReport, className }: AlertManagerViewProps): JSX.Element;
 
 export declare interface AlertManagerViewProps {
@@ -27,6 +78,91 @@ export declare interface AlertManagerViewProps {
     className?: string;
 }
 
+declare type AlertOperator = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'change_pct';
+
+export declare function AlertRuleDrawer({ open, definitions, editRule, preselectedDefinitionId, scopeSeeds, onClose, onSave, saving }: {
+    open: boolean;
+    definitions: MetricDefinition[];
+    editRule: MetricAlertRule | null;
+    preselectedDefinitionId?: number | null;
+    /** Pre-seeded filter values (e.g. from the user's scope restrictions), keyed by filter key. */
+    scopeSeeds?: Record<string, Array<string | number>>;
+    onClose: () => void;
+    onSave: (values: Record<string, unknown>) => void;
+    saving: boolean;
+}): JSX.Element;
+
+declare type AlertUnit = 'percent' | 'dollar' | 'count' | 'days';
+
+declare type AllocateDrawerConfig = {
+    /** Option collection browsed in the drawer (e.g. workflow_line_items). */
+    collection: string;
+    /** Grid FK column that receives the picked option's id. */
+    target_field: string;
+    /** Grid column that receives the entered amount. */
+    value_field: string;
+    title?: string;
+    value_label?: string;
+    /** Option filter — same '$parent.<field>' token semantics as option_filter. */
+    filter?: Record<string, unknown>;
+    /** Display columns over the option rows: dotted paths resolve via nested
+     *  field expansion; formula entries compute from the option row's values. */
+    columns?: Array<string | {
+        path?: string;
+        label?: string;
+        format?: string;
+        formula?: string;
+        width?: number;
+    }>;
+    /** Group option rows under collapsible headers by this (dotted) path —
+     *  EFP grouped allocation lines by workflow. Groups start collapsed;
+     *  groups containing an existing allocation start expanded. */
+    group_by?: string;
+    /** Per-row allocation ceiling formula (same tokens as column formulas incl.
+     *  {{__saved__}} = this row's saved amount): inputs clamp to it on commit
+     *  and show invalid state while exceeding it. */
+    value_max?: string;
+};
+
+declare interface AnomalyDefinition {
+    id: number;
+    key: string;
+    name: string;
+    description: string | null;
+    category: string;
+    status: string;
+    scope_options: FilterOptionSpec[] | null;
+    sensitivity_hints: Record<string, string> | null;
+}
+
+declare interface AnomalyRule {
+    id: number;
+    name: string;
+    definition_id: number;
+    sensitivity: 'low' | 'medium' | 'high' | string;
+    scopes: Record<string, Array<string | number>> | null;
+    check_frequency: 'daily' | 'weekly' | string;
+    delivery_in_app: boolean;
+    delivery_email: boolean;
+    status: string;
+    created_by: string | null;
+    definition?: {
+        id: number;
+        key: string;
+        name: string;
+        description: string | null;
+    };
+}
+
+export declare function AnomalyRuleDrawer({ open, definitions, editRule, onClose, onSave, saving }: {
+    open: boolean;
+    definitions: AnomalyDefinition[];
+    editRule: AnomalyRule | null;
+    onClose: () => void;
+    onSave: (values: Record<string, unknown>) => void;
+    saving: boolean;
+}): JSX.Element;
+
 /**
  * "The API was redeployed since you loaded this page" bar.
  *
@@ -58,18 +194,72 @@ export declare interface ApiVersionInfo {
     environment?: string;
 }
 
+/** Evaluate one field validation rule against a value. Returns an error message
+ *  or null. Shared by useNivaroForm (headless) and ItemEditForm (admin). */
+export declare function applyValidationRule(rule: FormValidationRule_2, value: unknown, label: string): string | null;
+
+declare type AutoAllocateConfig = {
+    /** Button label; defaults to 'Auto allocate'. */
+    label?: string;
+    /** drawer_relations entry (by field name) whose `match` supplies the
+     *  existing-allocation query + create defaults for this grid's rows. */
+    relation: string;
+    /** Grid row column holding the required quantity. */
+    row_qty_field: string;
+    /** Quantity column on the allocation rows. */
+    alloc_qty_field: string;
+    /** FK column on allocation rows pointing at a candidate record. */
+    fk_field: string;
+    candidates: {
+        collection: string;
+        /** Same '$parent.*' / '$row.*' token semantics as matched drawer filters. */
+        filters: Record<string, unknown>;
+        /** Server sort, e.g. 'date' for FIFO. */
+        sort?: string;
+        /** Gross capacity per candidate row, e.g. '0 - {{quantity}}'. */
+        capacity_formula: string;
+        /** Candidates with net capacity below this are skipped (default 1). */
+        min_capacity?: number;
+    };
+};
+
 declare type BinaryOp = '+' | '-' | '*' | '/' | '==' | '!=' | '<' | '<=' | '>' | '>=' | '&&' | '||';
 
 export declare function BooleanField({ field, value, onChange, error, disabled, readOnly, inputId, errorId }: FieldComponentProps): JSX.Element;
 
+export declare function buildGroups<T extends QueueGroupingRow>(rows: T[], attribute: string): QueueGroup<T>[];
+
 export declare function canOpenChatRoom(): boolean;
 
 export declare function canOpenDm(): boolean;
 
 export declare function canPreviewFile(type: string | null | undefined): boolean;
 
+/**
+ * Grab the replay link for an error being reported right now. Resolves null
+ * when no recorder is active (both settings off, recording failed, or the
+ * clip upload took longer than 4s) — error reporting must never wait on or
+ * break because of replay capture.
+ */
+export declare function captureErrorClip(): Promise<ErrorReplayLink | null>;
+
 export { CascadeFilterRule }
 
+declare type CascadeRule = {
+    parent_field: string;
+    child_field: string;
+};
+
+export declare function CellCopyLayer(): ReactPortal | null;
+
+declare interface ChannelMember {
+    user: string;
+    first_name: string | null;
+    last_name: string | null;
+    email: string | null;
+    joined_at: string;
+}
+
 declare interface ChannelMeta {
     id: number;
     visibility: 'open' | 'role' | 'private';
@@ -81,6 +271,26 @@ declare interface ChannelMeta {
 
 export declare function chatAvatarColor(id: string): string;
 
+/**
+ * Browse and join channels. The sidebar only lists rooms you belong to, so at
+ * hundreds of channels this is how you find the rest — the old list rendered
+ * every room anyone had ever posted in.
+ */
+export declare function ChatChannelBrowser({ onOpen }: {
+    onOpen: (room: string, label: string, channel: ChannelMeta) => void;
+}): JSX.Element;
+
+/**
+ * Channel settings. Owner or admin edits name/topic/visibility, manages members
+ * and archives; everyone else gets the read-only summary, so a member can still
+ * see what kind of room they are in and who else is here.
+ */
+export declare function ChatChannelSettings({ channel, label, onBack }: {
+    channel: ChannelMeta;
+    label: string;
+    onBack: () => void;
+}): JSX.Element;
+
 export declare interface ChatConfig {
     collections: {
         messages: string;
@@ -174,7 +384,7 @@ export declare function ChatPanel({ open, onClose, renderMessageBody, requestedD
 
 export declare function ChatProvider({ children, me, onlineUsers, collections, globalRoom, globalLabel, entityPattern, entityUrl, roomLabel, recordUrl, sessionUrl, realtime, subscribeRooms, setTypingRoom, navigate, sound, theme }: ChatProviderProps): JSX.Element;
 
-declare interface ChatProviderProps {
+export declare interface ChatProviderProps {
     children: React.ReactNode;
     me: ChatConfig['me'];
     onlineUsers?: ChatOnlineUser[];
@@ -239,6 +449,15 @@ export declare function ChatRoomView({ room, label, onBack, onOpenSettings, rend
     initialUnread?: number;
 }): JSX.Element;
 
+declare interface ChatSearchHit {
+    id: number;
+    room: string;
+    sender: string | null;
+    sender_name: string | null;
+    message: string;
+    date_created: string;
+}
+
 /**
  * Nivaro chat UI — a complete team panel (Online tab, grouped rooms, live
  * conversations with mentions, typing, receipts, search).
@@ -269,9 +488,80 @@ export declare interface ChatTheme {
     divider: string;
 }
 
+declare type CheckFrequency = 'hourly' | 'daily' | 'weekly';
+
+/**
+ * Select-choice display text. Legacy Directus schema imports store choice
+ * labels as i18n keys ('$t:published') that Directus resolved through its own
+ * translation bundle — Nivaro has no such bundle, so the raw key leaked into
+ * dropdowns and read views. Strip the marker and humanize; plain labels pass
+ * through untouched.
+ */
+export declare function choiceLabel(text: string | null | undefined): string;
+
 /** Clear the schema cache (e.g. after a schema change). */
 export declare function clearFormSchemaCache(collection?: string): void;
 
+declare interface ClientAction {
+    type: 'open-sidebar';
+    collection: string;
+    itemId: string;
+}
+
+export declare function CloneDialog({ collection, itemId, fields, relations, currentValues, onSuccess }: CloneDialogProps): JSX.Element;
+
+declare interface CloneDialogProps {
+    collection: string;
+    itemId: string;
+    fields: CMSField[];
+    relations: CMSRelation[];
+    currentValues: Record<string, unknown>;
+    onSuccess: (newId: string | number) => void;
+}
+
+declare interface CMSField {
+    field: string;
+    type: string;
+    interface: string | null;
+    label: string | null;
+    required: boolean;
+    hidden: boolean;
+    readonly: boolean;
+    sort: number;
+    group_key: string | null;
+    options: Record<string, unknown> | string | null;
+    computed_formula: string | null;
+    computed_type: string | null;
+    note: string | null;
+    placeholder: string | null;
+    repeater_schema: Record<string, unknown>[] | string | null;
+    dependency_config: Record<string, unknown> | string | null;
+    /** {source_collection, source_fk_field?, field_map:{target:source}} — live copy from a related record when the FK changes. */
+    cross_record_defaults?: Record<string, unknown> | string | null;
+    validation_rules?: Array<{
+        type: string;
+        value?: unknown;
+        message?: string;
+        soft?: boolean;
+    }> | string | null;
+    layout_assigned?: boolean;
+    /** Raw layout-assignment overrides (label, readonly, drilldown, ...) — passed through by field-config. */
+    _overrides?: Record<string, unknown> | null;
+}
+
+declare interface CMSRelation {
+    id: number;
+    one_collection: string | null;
+    one_field: string | null;
+    many_collection: string | null;
+    many_field: string | null;
+    junction_field: string | null;
+    /** M2A only — the junction column naming which collection each row's `item` id
+     *  belongs to (usually 'collection'); one_collection is null on those rows. */
+    one_collection_field?: string | null;
+    one_allowed_collections?: string | null;
+}
+
 /** @deprecated Column model changed to plain field keys — kept for source
  *  compatibility with early adopters; maps `path` to a field key. */
 export declare interface CollectionBrowserColumn {
@@ -317,7 +607,7 @@ export declare function CollectionImportPanel({ initialJobId, onJobOpen }: {
     onJobOpen?: (id: string | null) => void;
 }): JSX.Element;
 
-declare interface Column<T = Record<string, unknown>> {
+export declare interface Column<T = Record<string, unknown>> {
     key: string;
     header: React_2.ReactNode;
     sortable?: boolean;
@@ -326,7 +616,7 @@ declare interface Column<T = Record<string, unknown>> {
     render?: (row: T, index: number) => React_2.ReactNode;
 }
 
-declare type ColumnFormatConfig = {
+export declare type ColumnFormatConfig = {
     type: 'datetime';
     template: string;
 } | {
@@ -341,6 +631,11 @@ declare type ColumnFormatConfig = {
     false_label: string;
 };
 
+declare interface ColumnPreset {
+    name: string;
+    columns: string[];
+}
+
 export declare function CommentPanel({ collection, item, title, defaultExpanded, queuedComments, onQueueComment }: {
     collection: string;
     item: string | number;
@@ -374,7 +669,7 @@ export declare type ComponentOverrides = {
 
 export declare function DataTable<T = Record<string, unknown>>({ columns, rows, rowKey, total, page, limit, isLoading, isError, errorMessage, sort, onSortChange, onPageChange, onRowClick, searchValue, onSearchChange, searchPlaceholder, filterDefs, filterValues, onFilterChange, toolbarRight, emptyMessage, minBodyHeight, fillHeight, hideFilterRow, nowrapCells, density, pinFirstColumn, columnPins, onColumnPinChange, columnFilterRow, hScrollProxy, selectedIds, onSelectionChange, rowClassName, rowGroups, collapsedGroups, onToggleGroup }: DataTableProps<T>): React_2.JSX.Element;
 
-declare interface DataTableProps<T = Record<string, unknown>> {
+export declare interface DataTableProps<T = Record<string, unknown>> {
     columns: Column<T>[];
     rows: T[];
     rowKey?: (row: T, i: number) => string;
@@ -451,15 +746,37 @@ export declare function DateField({ field, value, onChange, error, disabled, rea
 /** The admin's route shape — the default when the host supplies no itemUrl. */
 export declare function defaultItemUrl(t: ItemLinkTarget): string;
 
+export declare function deriveGroupKey<T extends QueueGroupingRow>(row: T, attribute: string): string;
+
+declare interface DirectoryChannel {
+    id: number;
+    key: string;
+    name: string;
+    topic: string | null;
+    visibility: 'open' | 'role' | 'private';
+    role: string | null;
+    joined: boolean;
+    members: number;
+}
+
 declare type DmOpener = (userId: string, displayName?: string) => void;
 
 export declare function dmPeer(room: string, self: string): string | null;
 
 export declare function dmRoom(a: string, b: string): string;
 
+declare type DrawerRelationConfig = string | {
+    field: string;
+    hint?: {
+        sum_field: string;
+        cap_field: string;
+    };
+    match?: MatchedDrawerConfig;
+};
+
 export declare const DrilldownContext: React_2.Context<DrilldownContextValue | null>;
 
-declare interface DrilldownContextValue {
+export declare interface DrilldownContextValue {
     open: (target: DrilldownTarget) => void;
 }
 
@@ -482,6 +799,18 @@ export declare function effectiveScopeSeedIds(scopes: {
     restricted: Record<string, Array<string | number>>;
 }, dimName: string): Array<string | number>;
 
+export declare function ErpFailureBanner({ collection, itemId }: {
+    collection: string;
+    itemId: string;
+}): JSX.Element | null;
+
+export declare interface ErrorReplayLink {
+    recording_id: string;
+    /** Milliseconds into the recording where the error happened. Null for
+     *  clips — the whole clip IS the error context. */
+    offset_ms: number | null;
+}
+
 /** Boolean convenience — for guards and conditions. */
 export declare function evaluateBoolean(src: string, row: TokenResolver | Record<string, unknown>, opts?: EvaluateOptions): boolean;
 
@@ -491,7 +820,7 @@ export declare function evaluateExpression(src: string, resolve: TokenResolver |
 /** Numeric convenience — the shape every existing call site wants. */
 export declare function evaluateNumeric(src: string, row: TokenResolver | Record<string, unknown>, opts?: EvaluateOptions): number | null;
 
-declare interface EvaluateOptions {
+export declare interface EvaluateOptions {
     /**
      * What an unresolvable or non-numeric token means in arithmetic.
      * 'zero' (default) matches every existing dialect. 'null' propagates, so a
@@ -500,7 +829,7 @@ declare interface EvaluateOptions {
     missing?: 'zero' | 'null';
 }
 
-declare type ExprNode = {
+export declare type ExprNode = {
     kind: 'number';
     value: number;
 } | {
@@ -561,6 +890,18 @@ declare type ExprNode = {
  */
 export declare type ExprValue = number | string | boolean | null;
 
+/**
+ * Item-header chip summarizing every external (ERP) request this record has
+ * sent — badge counts by outcome, click for the full request/response log.
+ * Renders nothing when the record has no submissions. Shares the
+ * ['erp-submissions', collection, item] cache with ErpFailureBanner, so
+ * transition writebacks refresh both.
+ */
+export declare function ExternalRequestsChip({ collection, itemId }: {
+    collection: string;
+    itemId: string;
+}): JSX.Element | null;
+
 /** Field paths an expression reads, without evaluating it. */
 export declare function extractExpressionTokens(src: string): string[];
 
@@ -596,6 +937,31 @@ export declare type FieldComponentProps = {
 
 export { FieldDependencyConfig }
 
+export declare interface FieldDrilldownConfig {
+    enabled?: boolean;
+    layout_id?: number | null;
+    width?: number | string | null;
+}
+
+export declare function fieldDrilldownConfig(field: {
+    interface?: string | null;
+    _overrides?: Record<string, unknown> | null;
+}): FieldDrilldownConfig | null;
+
+export declare function FieldRenderer({ field, value, onChange, relations, collection, itemId, cascadeFilter, requiredParentLabel, onCountChange, displayOnly, prefillParentId }: {
+    field: CMSField;
+    value: unknown;
+    onChange: (v: unknown) => void;
+    relations: CMSRelation[];
+    collection: string;
+    itemId: string;
+    cascadeFilter?: Record<string, unknown>;
+    requiredParentLabel?: string | null;
+    onCountChange?: (count: number) => void;
+    displayOnly?: boolean;
+    prefillParentId?: string;
+}): JSX.Element;
+
 export declare type FieldState = {
     value: unknown;
     error: string[] | undefined;
@@ -621,7 +987,14 @@ export declare function FilePreviewLightbox({ file, onClose }: {
     onClose: () => void;
 }): ReactPortal;
 
-declare interface FilterDef {
+export declare function FilterControl({ def, value, onChange, layout }: {
+    def: FilterDef;
+    value: string | string[];
+    onChange: (value: string | string[]) => void;
+    layout?: 'inline' | 'stacked' | 'cell';
+}): React_2.JSX.Element;
+
+export declare interface FilterDef {
     key: string;
     placeholder: string;
     /** Defaults to 'select' — every existing FilterDef without this field keeps its current dropdown behavior unchanged. */
@@ -643,6 +1016,35 @@ declare interface FilterDef {
     restricted?: boolean;
 }
 
+export declare function filterDefLabel(def: FilterDef): string;
+
+declare interface FilterOptionSpec {
+    key: string;
+    label?: string;
+    collection?: string;
+    value_field?: string;
+    label_field?: string;
+    sort?: string;
+}
+
+/** Human display for an applied filter value — option labels for comboboxes
+ * (ids → names), ≥/≤ for ranges, first two entries + count for multiselects. */
+export declare function filterValueDisplay(def: FilterDef, value: string | string[]): string;
+
+export declare function formatDate(date: string | Date, opts?: Intl.DateTimeFormatOptions): string;
+
+export declare function formatDateTime(date: string | Date): string;
+
+export declare function formatFileSize(bytes: number | null | undefined): string;
+
+export declare function formatMultiValue(raw: string, cfg: ColumnFormatConfig): string;
+
+export declare function formatNumber(n: number | null | undefined): string;
+
+export declare function formatRelative(date: string | Date): string;
+
+export declare function formatValue(raw: string, cfg: ColumnFormatConfig): string;
+
 export declare type FormDirtyState = {
     isDirty: boolean;
     dirtyFields: string[];
@@ -699,7 +1101,7 @@ export declare type FormFieldType = 'text' | 'textarea' | 'integer' | 'float' |
 export declare type FormGroupDescriptor = {
     key: string;
     label: string;
-    type: 'section' | 'tab';
+    type: 'section' | 'tab' | 'metadata' | 'container';
     icon: string | null;
     sort: number;
     isCollapsed: boolean;
@@ -800,6 +1202,13 @@ export declare type FormValidationRule = {
     soft?: boolean;
 };
 
+declare type FormValidationRule_2 = {
+    type: string;
+    value?: unknown;
+    message?: string;
+    soft?: boolean;
+};
+
 /** A client-evaluable visibility rule. */
 export declare type FormVisibilityRule = {
     /** key of the field this rule observes */
@@ -817,18 +1226,25 @@ export declare function getMentionQuery(text: string, cursorPos: number): string
 
 export declare const GridFlushContext: React_2.Context<GridFlushContextValue | null>;
 
-declare type GridFlushContextValue = {
+export declare type GridFlushContextValue = {
     register: (key: string, fn: () => Promise<void>) => void;
     unregister: (key: string) => void;
 };
 
-declare interface HeaderWidgetInfo {
+export declare interface HeaderWidgetInfo {
     field: string;
     widgetId: number;
     label: string | null;
     inputBindings: InputBinding[];
 }
 
+/** Always-visible horizontal scrollbar proxy for the table scroller —
+ *  overlay-OS scrollbars hide, so wide tables get a persistent draggable
+ *  track pinned above the pagination footer. */
+export declare function HScrollProxy({ scrollerRef }: {
+    scrollerRef: React_2.RefObject<HTMLDivElement | null>;
+}): React_2.JSX.Element | null;
+
 /** Time without real input before someone counts as idle. */
 export declare const IDLE_AFTER_MS: number;
 
@@ -878,6 +1294,23 @@ export declare interface ImportDefinition {
     validation?: string | null;
 }
 
+export declare function ImportFromFileButton({ collection, templateFilter, getLabel, onParsed, compact }: {
+    collection: string;
+    templateFilter?: (t: ImportTemplateSummary) => boolean;
+    /** Per-template label source; defaults to the template's button_label. */
+    getLabel?: (t: ImportTemplateSummary) => string | null | undefined;
+    onParsed: (result: ImportParseResponse, template: ImportTemplateSummary) => void;
+    /** Grid-toolbar sizing (h-6, 11px) matching other inline-table buttons. */
+    compact?: boolean;
+}): JSX.Element | null;
+
+declare type ImportIssue = ImportParseResponse['issues'][number];
+
+export declare function ImportIssuesPanel({ issues, onDismiss }: {
+    issues: ImportIssue[];
+    onDismiss?: () => void;
+}): JSX.Element | null;
+
 export declare interface ImportJob {
     id: string;
     collection: string;
@@ -1006,15 +1439,76 @@ declare interface ImportValidationReport {
     truncated: boolean;
 }
 
+export declare function InlineTableField({ relatedCollection, manyField, parentId, parentCollection, layoutId, showRowRevisions, allowRevisionRestore, saveMode, showLineNumbers, enableReorder, parentCascades, rowRules, columnPresets, defaultPreset, drawerRelations, parentContextFields, uniqueBy, sortField, sortDir, sectionGroupBy, rowFilter, rowDefaults, allocateDrawer, autoAllocate, rowBulkActions, uploadTemplate, submissionErrors, prefillParentId, parentFieldKey, readOnly }: {
+    relatedCollection: string;
+    manyField: string;
+    parentId: string;
+    /** Same table display, but no editing: hides the Add toolbar, + Add row,
+     *  row delete/undo, and blocks cell edit entry. */
+    readOnly?: boolean;
+    parentCollection?: string;
+    layoutId?: number | null;
+    showRowRevisions?: boolean;
+    allowRevisionRestore?: boolean;
+    saveMode?: 'immediate' | 'pending';
+    showLineNumbers?: boolean;
+    enableReorder?: boolean;
+    parentCascades?: CascadeRule[];
+    rowRules?: RowRule[];
+    columnPresets?: ColumnPreset[];
+    /** Initial view before the user picks one: a preset name or '__all__'. */
+    defaultPreset?: string;
+    drawerRelations?: DrawerRelationConfig[];
+    parentContextFields?: string[];
+    uniqueBy?: string[];
+    sortField?: string;
+    sortDir?: 'asc' | 'desc';
+    /** Dotted relation path on the child collection (e.g. 'item.category.name'):
+     *  saved rows render grouped into collapsible sections by the resolved value. */
+    sectionGroupBy?: string;
+    /** Static filter narrowing which child rows this grid shows — flat {col: value}
+     *  entries become _eq, object values pass through as filter operators. Lets two
+     *  grids on the same relation show disjoint views (e.g. is_osp split). */
+    rowFilter?: Record<string, unknown>;
+    /** Values seeded onto every NEW row created from this grid (e.g. {is_osp: true}). */
+    rowDefaults?: Record<string, unknown>;
+    /** EFP-style allocate drawer: browse all eligible options, type amounts. */
+    allocateDrawer?: AllocateDrawerConfig;
+    autoAllocate?: AutoAllocateConfig;
+    /** Toolbar buttons that rewrite EVERY row in one go from an aggregate of a
+     *  related collection — the generic form of EFP's "Close Out Lines" (reduce
+     *  each REQ line by the open unbilled amount across its PO lines). */
+    rowBulkActions?: RowBulkActionConfig[];
+    /** Import template NAME — renders that template's upload button in this
+     *  grid's toolbar (existing records; wired to ItemEditForm's reimport flow). */
+    uploadTemplate?: string;
+    /** Flag rows a failed ERP push rejected (options.submission_errors) — the
+     *  latest failed nivaro_erp_submissions row for the PARENT record is parsed
+     *  for "LineNumber N: reason" entries and matching rows tint red with the
+     *  reason beneath. `line_field` = the row column holding the pushed line
+     *  number (default 'line_number'). Mirrors CatalogPickerField's
+     *  submission_errors for catalog grids. */
+    submissionErrors?: {
+        line_field?: string;
+    };
+    prefillParentId?: string;
+    parentFieldKey?: string;
+}): JSX.Element;
+
 declare interface InputBinding {
     key: string;
     binding_type: 'item_field' | 'static' | 'url_param';
     binding_value: string;
 }
 
+export declare function ItemActionButtons({ collection, itemId }: {
+    collection: string;
+    itemId: string;
+}): JSX.Element | null;
+
 export declare const ItemEditAuthContext: React_2.Context<ItemEditAuthContextValue>;
 
-declare type ItemEditAuthContextValue = {
+export declare type ItemEditAuthContextValue = {
     isAdmin: boolean;
     userId: string;
 };
@@ -1095,6 +1589,73 @@ export declare function ItemLockBanner({ lockHolder, onTakeOver, takingOver, isA
     isAdmin?: boolean;
 }): JSX.Element | null;
 
+export declare function JsonMapEditor({ config, scope }: {
+    config: JsonMapEditorConfig;
+    scope: Record<string, unknown>;
+}): JSX.Element;
+
+declare interface JsonMapEditorConfig {
+    collection: string;
+    title?: string;
+    /** Record picker label field (also the required name on create). */
+    label_field?: string;
+    /** Filter for the record picker; '$scope.<field>' tokens resolve from the
+     *  host-provided scope. Scope values are also seeded onto created records. */
+    record_filter?: Record<string, unknown>;
+    /** Plain record fields edited beside the picker (small option sets). */
+    fields?: Array<{
+        field: string;
+        label?: string;
+        options: string[];
+    }>;
+    /** JSON-dict columns; each stored under `json_field` on the record. */
+    map_columns: Array<{
+        json_field: string;
+        label: string;
+        min?: number;
+        max?: number;
+    }>;
+    /** Key rows: records of other collections. Template supports one-hop dotted
+     *  refs ('{{core_category.name}}'); filter supports '$scope' tokens. */
+    sections: Array<{
+        collection: string;
+        label_template: string;
+        filter?: Record<string, unknown>;
+        section_label?: string;
+    }>;
+    /** Static sentinel keys appended after the sections (bg = row tint). */
+    extra_rows?: Array<{
+        key: string;
+        label: string;
+        bg?: string;
+    }>;
+    /** 'Left to allocate' style hint: shown when record[when_field] ===
+     *  when_value; remaining = total − Σ json_field values. */
+    remaining_hint?: {
+        when_field: string;
+        when_value: string;
+        total: number;
+        json_field: string;
+        label?: string;
+    };
+    /** Extra fields seeded onto created records from scope values. */
+    seed_fields?: string[];
+    /** Custom query run after save (recompute hooks); '$scope' tokens. */
+    after_save?: {
+        query_slug: string;
+        params?: Record<string, unknown>;
+    };
+}
+
+declare interface LayoutAssignment {
+    field: string;
+    group_key: string | null;
+    sort: number;
+    label_override: string | null;
+    is_visible: boolean | number;
+    overrides?: string | Record<string, unknown> | null;
+}
+
 /**
  * Full layout-aware form renderer.
  *
@@ -1153,6 +1714,13 @@ declare type LayoutFormProps = {
     layoutSlug?: string;
 };
 
+declare interface LayoutGroup {
+    key: string;
+    label: string;
+    type: string | null;
+    sort: number;
+}
+
 export declare type LayoutItem = FormGroupDescriptor | '__ungrouped__';
 
 declare interface LockHolder {
@@ -1160,6 +1728,25 @@ declare interface LockHolder {
     locked_by_name: string | null;
 }
 
+export declare interface M2MStagingCtx {
+    getStagedLinks: (key: string) => unknown[];
+    getStagedUnlinks: (key: string) => Set<unknown>;
+    stageLink: (key: string, relatedId: unknown) => void;
+    stageUnlink: (key: string, junctionId: unknown) => void;
+    unstageLink: (key: string, relatedId: unknown) => void;
+    unstageUnlink: (key: string, junctionId: unknown) => void;
+}
+
+declare type MatchedDrawerConfig = {
+    /** Rows selected by filter instead of an FK to the child row — values may be
+     *  '$parent.id', '$parent.<field>', '$row.<field>', or literals; dotted keys
+     *  become nested relation filters. Creates are seeded with `defaults`
+     *  (same token resolution, plain columns only). */
+    collection: string;
+    filters: Record<string, unknown>;
+    defaults?: Record<string, unknown>;
+};
+
 /** Match a filter surface (by its own key and/or its options collection) to a
  *  scope dimension. Convention: key === dimension name wins, else the filter's
  *  options collection === the dimension's target collection. */
@@ -1168,22 +1755,147 @@ export declare function matchScopeDimension(scopes: UserScopesInfo | null, probe
     collection?: string;
 }): UserScopesInfo['dimensions'][number] | null;
 
+export declare function MatrixEditor({ config, initialScope }: {
+    config: MatrixEditorConfig;
+    /** Pre-seed scope pickers (drill-down hosts scope the matrix to a record). */
+    initialScope?: Record<string, unknown>;
+}): JSX.Element;
+
+declare interface MatrixEditorConfig {
+    title?: string;
+    target_collection: string;
+    option_collection: string;
+    /** Plain display column (default 'name') — or use option_label_template. */
+    option_label?: string;
+    /** Dotted display template, e.g. '{{core_category.name}} - {{sub_category.name}}'. */
+    option_label_template?: string;
+    /** Filter for the option fetch. '$scope.<field>' tokens resolve from scope. */
+    option_filter?: Record<string, unknown>;
+    key_field: string;
+    value_field: string;
+    value_label?: string;
+    value_format?: 'currency' | 'number';
+    /** Scope pickers. `filter` narrows a picker's options; '$scope.<field>'
+     *  tokens resolve from the other scope values (EFP: sub types limited to the
+     *  chosen project's linked sub types) — unresolved tokens drop the filter. */
+    scope_fields: Array<{
+        field: string;
+        collection: string;
+        label?: string;
+        filter?: Record<string, unknown>;
+    }>;
+    /** Third level: sub-group options WITHIN a group section by a template over
+     *  the option record (EFP region → core category → Labor/Materials/Equipment:
+     *  label_template '{{core_category.name}}', row_label_template
+     *  '{{sub_category.name}}'). Sub-headers aggregate their children and
+     *  collapse independently. */
+    option_section?: {
+        label_template: string;
+        /** Leaf row label; defaults to the full option label. */
+        row_label_template?: string;
+    };
+    /** Second axis: sections per group record; target rows keyed (key, group, scope). */
+    group?: {
+        field: string;
+        collection: string;
+        label_field?: string;
+        filter?: Record<string, unknown>;
+    };
+    /** Extra seeds on created rows, '$<scopeField>.<path>' — path may be dotted
+     *  and use [n] (e.g. '$project.funding_years[0].funding_year'). */
+    scope_seeds?: Record<string, string>;
+    /** Auto-fill a scope picker from another scope record when empty, e.g.
+     *  {project_sub_type: '$project.default_sub_type'} (EFP default sub type). */
+    scope_defaults?: Record<string, string>;
+    /** Seeds copied from the GROUP record onto rows created in that section,
+     *  {targetField: groupField} — e.g. {division: 'division'} (allocation rows
+     *  carry the region's division, not one picked from the project). */
+    group_seeds?: Record<string, string>;
+    /** Cap strip: cap value read from a scope record's field; total of all cells
+     *  is clamped so it never exceeds the cap (server sum_cap should back this). */
+    cap?: {
+        scope_field: string;
+        field: string;
+        label?: string;
+    };
+    /** Synthetic rows per group for target rows with a NULL key (Uncategorized)
+     *  and/or a boolean bucket flag (Inventory: rows with flag true, key null). */
+    specials?: {
+        uncategorized?: {
+            label?: string;
+            metric_value?: number | null;
+        };
+        bucket?: {
+            flag_field: string;
+            label?: string;
+            metric_value?: number | null;
+        };
+    };
+    /** Per-cell read-only metric columns from a custom query. */
+    metrics?: {
+        query_slug: string;
+        params?: Record<string, unknown>;
+        match_option_field: string;
+        match_group_field?: string;
+        columns: Array<{
+            field: string;
+            label?: string;
+            format?: 'currency' | 'number';
+        }>;
+    };
+}
+
 declare interface MessageToken {
     text: string;
     entity?: string;
     mention?: string;
 }
 
+declare interface MetricAlertRule {
+    id: number;
+    name: string;
+    definition_id: number;
+    operator: string;
+    threshold_value: number;
+    filters: Record<string, Array<string | number>> | null;
+    check_frequency: CheckFrequency | string;
+    is_shared: boolean;
+    status: string;
+    created_by: string | null;
+    created_at: string | null;
+    definition?: {
+        id: number;
+        name: string;
+        description: string | null;
+        category: string;
+        unit: string;
+    };
+}
+
+declare interface MetricDefinition {
+    id: number;
+    name: string;
+    description: string | null;
+    metric_key: string;
+    category: string;
+    unit: AlertUnit | string;
+    default_operator: AlertOperator | string;
+    default_threshold: number | null;
+    supported_filters: FilterOptionSpec[] | null;
+    status: string;
+    sort: number | null;
+}
+
 export declare function MyWorkView({ notificationRoutes, onOpenPath }?: {
     /** Host page map so notification clicks land on real pages (reports, queues,
      *  alerts…); without it only record targets are clickable. */
-    notificationRoutes?: NotificationRouteMap_2;
+    notificationRoutes?: NotificationRouteMap;
     onOpenPath?: (path: string) => void;
 }): JSX.Element;
 
 export declare const NavigationContext: React_2.Context<NavigationContextValue>;
 
-declare type NavigationContextValue = {
+export declare type NavigationContextValue = {
     /** `options.state` rides along for hosts whose router supports it (e.g. react-router's
      *  useNavigate) — hosts that ignore the second argument still navigate correctly. */
     navigate: (path: string, options?: {
@@ -1271,34 +1983,7 @@ export declare function normalizeFieldType(rawType: string, iface: string | null
  * system collections map to their owning pages, and the pseudo-collection
  * `__chat__` carries a chat room key.
  */
-
 export declare interface NotificationRouteMap {
-    /** Record route for a business collection — return null when the host has none. */
-    record: (collection: string, item: string) => string | null
-    /** Collection listing (item-less business notifications, e.g. view digests). */
-    list?: (collection: string) => string | null
-    report?: (id: string) => string | null
-    queue?: (id: string) => string | null
-    dashboard?: (id: string) => string | null
-    /** Alert-manager page (metric/anomaly/per-record alert notifications). */
-    alerts?: () => string | null
-    imports?: () => string | null
-    issues?: () => string | null
-}
-
-/**
- * Every in-app notification must land somewhere meaningful — this is the ONE
- * resolver both bells, the notifications page, and My Work use to decide what
- * a click does. A row that resolves to null renders as plain text (no hover,
- * no cursor), which is the honest state for broadcast-style messages; it must
- * never render as a link that goes nowhere.
- *
- * Server writers use `collection` + `item` as the target: business collections
- * point at records (or the collection list when item is null), a handful of
- * system collections map to their owning pages, and the pseudo-collection
- * `__chat__` carries a chat room key.
- */
-declare interface NotificationRouteMap_2 {
     /** Record route for a business collection — return null when the host has none. */
     record: (collection: string, item: string) => string | null;
     /** Collection listing (item-less business notifications, e.g. view digests). */
@@ -1312,13 +1997,19 @@ declare interface NotificationRouteMap_2 {
     issues?: () => string | null;
 }
 
-export declare type NotificationTarget =
-| { type: 'path'; path: string }
-| { type: 'chat'; room: string }
-| null
+export declare type NotificationTarget = {
+    type: 'path';
+    path: string;
+} | {
+    type: 'chat';
+    room: string;
+} | null;
 
 export declare function NumberField({ field, value, onChange, error, disabled, readOnly, inputId, errorId }: FieldComponentProps): JSX.Element;
 
+/** Intl options for a numeric field, honoring its configured precision. */
+export declare function numericIntlOptions(options: unknown, format?: string): Intl.NumberFormatOptions;
+
 declare interface O2MFieldInfo {
     field: string;
     label: string;
@@ -1375,6 +2066,13 @@ declare interface OwnerLike {
     name: string;
 }
 
+export declare function OwnersSlot({ collection, item, title, defaultExpanded }: {
+    collection: string;
+    item: string;
+    title?: string;
+    defaultExpanded?: boolean;
+}): JSX.Element | null;
+
 export declare function PageRenderer({ slug, hideHeader, className }: PageRendererProps): JSX.Element;
 
 export declare interface PageRendererPage {
@@ -1413,7 +2111,7 @@ declare interface ParseFailure {
     position: number;
 }
 
-declare type ParseResult = ParseSuccess | ParseFailure;
+export declare type ParseResult = ParseSuccess | ParseFailure;
 
 declare interface ParseSuccess {
     ok: true;
@@ -1428,6 +2126,14 @@ declare interface PendingTask {
     due_date: string;
 }
 
+declare interface PinnedMessage {
+    pin_id: number;
+    id: number;
+    sender_name: string | null;
+    message: string;
+    date_created: string;
+}
+
 export declare function PipelinePanel({ collection, item, defaultExpanded, title, showApprovalChain, onBeforeTransition, addendumPending, addendumView }: {
     collection: string;
     item: string;
@@ -1445,6 +2151,17 @@ export declare function PipelineTransitionButtons({ collection, item, onBeforeTr
     onBeforeTransition?: () => boolean | Promise<boolean>;
 }): JSX.Element | null;
 
+/**
+ * How many decimal places a numeric field wants, from its `precision` option.
+ *
+ * One helper because the answer was hardcoded to 2 in five places — the field
+ * input, the inline grid's cells, its formula and aggregate columns, and the
+ * read-only display — so a field configured for 4 showed 4 in one of them and
+ * 2 everywhere else. Out-of-range or missing values fall back rather than
+ * throwing at Intl, which rejects anything outside 0–20.
+ */
+export declare function precisionOf(options: unknown, fallback?: number): number;
+
 /**
  * Inline attachment preview — click a file, see it, without a download round
  * trip. Images, PDFs, video and audio render in an overlay; anything else
@@ -1467,6 +2184,136 @@ export declare function ProfileView({ userId, className }: {
     className?: string;
 }): JSX.Element;
 
+export declare function QueryStatStrip({ stats, rows, effectiveParams, loading }: {
+    stats: QueryWidgetStat[];
+    rows: Array<Record<string, unknown>>;
+    effectiveParams: Record<string, unknown>;
+    loading: boolean;
+}): JSX.Element | null;
+
+export declare function QueryTable({ rows, config, onRowClick, pivotYear, rowActions }: {
+    rows: Array<Record<string, unknown>>;
+    config?: QueryTableConfig;
+    /** Makes rows clickable (hover highlight); receives the (post-grouping) row. */
+    onRowClick?: (row: Record<string, unknown>) => void;
+    /** Resolved pivot year (from the widget's params) — overrides config.pivot.year. */
+    pivotYear?: number;
+    /** Trailing action buttons per row (and on the totals row, receiving null). */
+    rowActions?: Array<{
+        label: string;
+        onClick: (row: Record<string, unknown> | null) => void;
+    }>;
+}): JSX.Element;
+
+declare interface QueryTableColumn {
+    /** Row key. Omit for pure formula columns. */
+    field?: string;
+    label?: string;
+    format?: 'currency' | 'number' | 'percent' | 'text';
+    /** Arithmetic over {{col}} refs, e.g. '{{carAmount}} - {{allocated}}' or
+     *  '{{allocated}} / {{carAmount}} * 100'. Evaluated per row (and over the
+     *  totals row for the footer). */
+    formula?: string;
+    /** Include in the totals footer (plain fields sum; formula columns re-run
+     *  the formula over the summed values — weighted, not averaged). */
+    sum?: boolean;
+    /** 'progress' renders the value with a bar underneath, filled to
+     *  value / progress_max (EFP PUB'd-vs-budget style). Over 100% turns red. */
+    display?: 'progress';
+    /** Denominator for display 'progress': a row field name or a {{col}} formula. */
+    progress_max?: string;
+    /** Column group label. When any column has one, the header renders two
+     *  rows — group cells spanning their children ('Jan' over Fcst/Act) — and
+     *  alternating groups get a faint band so wide grids stay scannable. */
+    group?: string;
+    /** Cell text color (any CSS color) — EFP forecast/actual column tinting.
+     *  color_dark overrides in dark mode (defaults to color). */
+    color?: string;
+    color_dark?: string;
+    /** Second field rendered as a stacked line under the main value in the SAME
+     *  cell (EFP month cells: Fcst over Act — halves the column count). Toggles
+     *  hide individual lines; the column collapses when both lines hide. */
+    stack?: string;
+    stack_color?: string;
+    stack_color_dark?: string;
+}
+
+declare interface QueryTableConfig {
+    columns?: QueryTableColumn[];
+    /** Group rows by this field, summing every numeric column per group. */
+    group_by?: string;
+    /** Render the totals footer row. */
+    totals?: boolean;
+    /** Collapsible section rows: one header row per distinct value of this
+     *  field (per-column sums on the header), child rows listed under it.
+     *  Unlike group_by (which REPLACES rows with aggregates), children stay. */
+    tree_group_by?: string;
+    /** Sections start collapsed (default false = expanded). */
+    tree_collapsed?: boolean;
+    /** SECOND tree level inside each section, derived by splitting `field` on
+     *  its LAST `separator` (default ' - '): left side = collapsible summed
+     *  sub-section (category), right side = the leaf's label (Labor/Materials).
+     *  Rows without the separator stay directly under the section. */
+    tree_sub_split?: {
+        field: string;
+        separator?: string;
+    };
+    /** Sub-sections start collapsed (default true). */
+    tree_sub_collapsed?: boolean;
+    /** Leaf rows strip a leading '<section name> - ' from the first column —
+     *  de-duplicates labels when the section field is the label's prefix. */
+    tree_strip_section_prefix?: boolean;
+    /** Per-row numeric format override: name of a row field holding
+     *  'currency' | 'number' — lets unit-count rows sit alongside dollar rows
+     *  (EFP forecasting grid). Falls back to the column format. */
+    row_format_field?: string;
+    /** Pin the first column and the header row while the grid scrolls — wide
+     *  month grids keep their row labels in view. */
+    sticky?: boolean;
+    /** Render zeroes as an em dash — de-noises mostly-empty month grids. */
+    zero_dash?: boolean;
+    /** Column show/hide toggle pills above the table (EFP Actuals / Forecasts /
+     *  Calendar Year). A toggle turned OFF hides columns matched by exact
+     *  `fields` or a field-name `suffix` — unless `hide_when_on` inverts it
+     *  (Calendar Year ON hides the Prior/Carryover columns). */
+    toggles?: Array<{
+        label: string;
+        fields?: string[];
+        suffix?: string;
+        default_on?: boolean;
+        hide_when_on?: boolean;
+    }>;
+    /** Tint every column of this group (header + cells + totals). The sentinel
+     *  '$current_month' resolves to the current month's short label (Jan…Dec).
+     *  Pair with highlight_year_param so it only applies on the current year. */
+    highlight_group?: string;
+    /** Widget-layer guard: name of the effective param holding the selected
+     *  year — highlight_group is dropped unless it equals the current year. */
+    highlight_year_param?: string;
+    /** Tiny colored line-name legend under stacked-column headers, e.g.
+     *  ['Fcst', 'Act'] (EFP listHeaderSubLabel). */
+    stack_legend?: [string, string];
+    /** Pivot long rows into month columns BEFORE rendering. Rows sharing the
+     *  same key fields merge into one row with Jan…Dec (+ optional
+     *  prior/later-year buckets and a total) from `value_field`, driven by a
+     *  'yyyy-MM' `date_field` and the `year` param/prop. */
+    pivot?: {
+        date_field: string;
+        value_field: string;
+        /** Fields that identify a row (everything else is dropped). */
+        key_fields: string[];
+        /** Which year's months to expand; other years fold into per-year columns.
+         *  Resolved from the widget's effective params when `year_param` set. */
+        year?: number;
+        year_param?: string;
+        /** Add a Total column summing every pivoted cell. */
+        total?: boolean;
+        /** Render a Months/Quarters toggle above the table (EFP quarterly view).
+         *  Quarter columns sum their three months — same drill/total math. */
+        quarter_toggle?: boolean;
+    };
+}
+
 export declare function QueryWidgetBody({ cfg, dateRange, entityFilters, refetchInterval, onStatus, onDrill }: {
     cfg: ReportQueryWidgetConfig;
     dateRange: ReportDateRange | null;
@@ -1483,6 +2330,42 @@ export declare function QueryWidgetBody({ cfg, dateRange, entityFilters, refetch
     }) => void;
 }): JSX.Element;
 
+declare interface QueryWidgetStat {
+    label: string;
+    /** Sum this field over the main query's rows. */
+    field?: string;
+    format?: 'currency' | 'number';
+    /** Hover breakdown: each entry summed over the same rows. */
+    details?: Array<{
+        label: string;
+        field: string;
+    }>;
+    /** Independent source: own custom query. Value = sum of value_field over its
+     *  rows; when label_field set, rows also list in the hover breakdown.
+     *  param_from copies values from the main widget's effective params
+     *  {statQueryParam: widgetParam}. */
+    query?: {
+        slug: string;
+        params?: Record<string, unknown>;
+        param_from?: Record<string, string>;
+        value_field: string;
+        label_field?: string;
+    };
+    /** Card tint (any CSS color, e.g. '#f9fbd1'). */
+    bg?: string;
+    /** Only sum rows matching these field values (equality AND) — EFP
+     *  forecasting stats scope to the Workflow Forecast section. */
+    row_match?: Record<string, unknown>;
+    /** Delta stat: value = sum(field) − sum(field_subtract); positive values
+     *  render with a leading '+'. */
+    field_subtract?: string;
+    /** EFP stat-card accent: colored top border + value (accent_dark in dark
+     *  mode; accent_negative when a delta goes negative). */
+    accent?: string;
+    accent_dark?: string;
+    accent_negative?: string;
+}
+
 export declare function QueueBulkBar({ count, states, busy, claimsEnabled, onClaim, onRelease, onTransition, onClear }: {
     count: number;
     states: Array<{
@@ -1497,6 +2380,25 @@ export declare function QueueBulkBar({ count, states, busy, claimsEnabled, onCla
     onClear: () => void;
 }): JSX.Element | null;
 
+export declare interface QueueGroup<T extends QueueGroupingRow = QueueGroupingRow> {
+    key: string;
+    rows: T[];
+    breached: number;
+    atRisk: number;
+}
+
+declare interface QueueGroupingRow {
+    collection: string;
+    state: string | null;
+    sla_status: 'ok' | 'warning' | 'breached' | null;
+    at_risk: boolean;
+    owners: {
+        name: string;
+    }[];
+    aging_hours: number | null;
+    extra?: Record<string, unknown>;
+}
+
 declare interface QueueItemRow {
     collection: string;
     item_id: string;
@@ -1595,6 +2497,23 @@ declare interface QuickFilterDef {
     sort?: string;
 }
 
+/** The reaction palette — mirrored server-side; anything else is rejected. */
+export declare const REACTION_EMOJI: readonly ["👍", "✅", "👀", "🎉", "❤️", "😂"];
+
+export declare interface ReadViewLayout {
+    layout: {
+        id: number;
+        name: string;
+    };
+    groups: LayoutGroup[];
+    assignments: LayoutAssignment[];
+}
+
+export declare function RecordChatActions({ collection, itemDraft }: {
+    collection: string;
+    itemDraft: Record<string, unknown>;
+}): JSX.Element | null;
+
 export declare function RecordDrilldownSheet({ collection, itemId, layoutId, rootLayoutSlug, width, title, stack: controlledStack, onPush, onPop, onClose }: {
     collection: string;
     itemId: string;
@@ -1616,11 +2535,150 @@ export declare function RecordDrilldownSheet({ collection, itemId, layoutId, roo
     onClose: () => void;
 }): JSX.Element;
 
+export declare function RecordGridEditor({ config }: {
+    config: RecordGridEditorConfig;
+}): JSX.Element;
+
+declare interface RecordGridEditorConfig {
+    collection: string;
+    title?: string;
+    /** Scope pickers: every field must be chosen before rows load; values filter
+     *  loaded rows and seed created rows. `filter` supports '$scope.<field>'
+     *  tokens off the other scope values. */
+    scope?: Array<{
+        field: string;
+        collection: string;
+        label?: string;
+        filter?: Record<string, unknown>;
+    }>;
+    /** Free-form identity pickers on each row (year / division / …) — part of
+     *  what makes a row unique; rendered as comboboxes on NEW rows, read-only
+     *  labels on existing ones. */
+    key_columns?: Array<{
+        field: string;
+        label?: string;
+        collection: string;
+    }>;
+    /** One editable row per record of this collection; existing target rows are
+     *  matched via fk_field. `filter` supports '$scope.<field>' tokens. */
+    row_source?: {
+        collection: string;
+        label_field: string;
+        fk_field: string;
+        filter?: Record<string, unknown>;
+        sort?: string;
+    };
+    /** Plain editable numeric columns. */
+    columns?: Array<{
+        field: string;
+        label?: string;
+        readonly?: boolean;
+    }>;
+    /** Generates january…december editable columns per set (field =
+     *  '<month><suffix>'). */
+    month_sets?: Array<{
+        suffix: string;
+        label: string;
+    }>;
+    allow_add?: boolean;
+    allow_delete?: boolean;
+    /** Written on save as the sum of the FIRST month set's values. */
+    computed_total_field?: string;
+    /** Custom query run after a successful save — params support '$scope.<f>'. */
+    after_save?: {
+        query_slug: string;
+        params?: Record<string, unknown>;
+    };
+    /** Nested map editors opened from toolbar buttons (EFP Manage Cost Tables) —
+     *  receive the current scope; enabled once `require_scope` fields are set. */
+    toolbar_editors?: Array<{
+        button_label: string;
+        sheet_width?: number | string;
+        require_scope?: string[];
+        json_map: JsonMapEditorConfig;
+    }>;
+}
+
+export declare function RecordReadView({ collection, itemId, layoutData }: {
+    collection: string;
+    itemId: string;
+    layoutData: ReadViewLayout;
+}): JSX.Element;
+
+/**
+ * "Since you last looked" — opening a saved record touches the per-user view
+ * watermark and, when other people changed the record in between, renders a
+ * one-line recap above the form. The server owns the session semantics (a
+ * refresh within 30 minutes keeps the same baseline), the strip just shows
+ * whatever the touch returned. Dismiss is per-mount — the next genuine visit
+ * recomputes against the new baseline anyway.
+ */
+export declare function RecordRecapStrip({ collection, itemId }: {
+    collection: string;
+    itemId: string;
+}): JSX.Element | null;
+
+/**
+ * Per-record notification subscription — a bell in the item header that lets
+ * any user watch this specific record. Backed entirely by the existing
+ * nivaro_notification_subscriptions engine:
+ *
+ *   State changes only → one event_type='workflow_transition' row scoped to
+ *     the record via filters [{field:'id', op:'eq', value:<id>}] (filter_field
+ *     stays null — on transition subs it means "to_state").
+ *   All changes → that row PLUS an event_type='all' row scoped via
+ *     filter_field='id' / filter_value (the create/update/delete path reads
+ *     only the flat filter pair, never the filters JSON).
+ *
+ * Transitions never fire the items-service update hook (state mirrors are raw
+ * writes), so the two rows can't double-notify.
+ */
+export declare function RecordSubscribeButton({ collection, itemId, recordLabel }: {
+    collection: string;
+    itemId: string;
+    recordLabel?: string;
+}): JSX.Element;
+
 /** Register the host's DM opener. Returns an unregister function. */
 export declare function registerDmOpener(fn: DmOpener): () => void;
 
 export declare function registerRoomOpener(fn: RoomOpener): () => void;
 
+export declare function RelatedRecordsPanel({ collection, itemId, defaultExpanded }: {
+    collection: string;
+    itemId: string;
+    defaultExpanded?: boolean;
+}): JSX.Element;
+
+export declare function RelationCombobox({ collection, value, onChange, disabled, placeholder, extraFilter, autoSelectSingle, optionSort, requiredParent, facets, fieldKey }: {
+    collection: string;
+    value: unknown;
+    onChange: (v: unknown) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    extraFilter?: Record<string, unknown>;
+    /** When the filtered option set has EXACTLY one option and the field is
+     *  empty, pick it automatically (options.auto_select_single). Two or more
+     *  options — or zero — leave the field blank; an existing value is never
+     *  overridden. Re-evaluates when the effective filter changes (e.g. a
+     *  cascade parent narrowing the list). */
+    autoSelectSingle?: boolean;
+    /** Option ordering: 'column' | '-column' (server sort) | 'label' | '-label' (display-label sort). Default: label ascending. */
+    optionSort?: string;
+    requiredParent?: string;
+    /** Field name, so staleness can be reported to the form by name. */
+    fieldKey?: string;
+    /** In-picker filter facets: M2O fields ON THE TARGET COLLECTION rendered as
+     *  small pickers inside the dropdown. Ephemeral — they only narrow the
+     *  option list, nothing is written to the form. */
+    facets?: Array<{
+        field: string;
+        label?: string;
+        sort?: string;
+        filter?: Record<string, unknown>;
+    }>;
+}): JSX.Element;
+
 /**
  * Unstyled relation picker.
  *  - m2o: single <select> of related items
@@ -1641,7 +2699,7 @@ export declare type RelationOption = {
     raw: Record<string, unknown>;
 };
 
-declare type RenderFieldProps = {
+export declare type RenderFieldProps = {
     field: any;
     value: unknown;
     onChange: (v: unknown) => void;
@@ -1684,56 +2742,9 @@ export declare interface ReportViewProps {
     emptyState?: React.ReactNode;
 }
 
-export declare function resolveNotificationTarget(
-collection: string | null | undefined,
-item: string | null | undefined,
-routes: NotificationRouteMap
-): NotificationTarget {
-    const c = collection?.trim()
-    if (!c) return null
-    const i = item != null && String(item).trim() !== '' ? String(item) : null
-
-    if (c === '__chat__') {
-        // Opening a room needs a registered chat dock — without one there is no
-        // chat surface to open, so the row stays plain.
-        return i && canOpenChatRoom() ? { type: 'chat', room: i } : null
-    }
-
-    if (c === 'nivaro_report_defs') {
-        const p = i ? routes.report?.(i) : null
-        return p ? { type: 'path', path: p } : null
-    }
-    if (c === 'nivaro_queues') {
-        const p = i ? routes.queue?.(i) : null
-        return p ? { type: 'path', path: p } : null
-    }
-    if (c === 'nivaro_dashboards') {
-        const p = i ? routes.dashboard?.(i) : null
-        return p ? { type: 'path', path: p } : null
-    }
-    if (ALERT_COLLECTIONS.has(c)) {
-        const p = routes.alerts?.()
-        return p ? { type: 'path', path: p } : null
-    }
-    if (IMPORT_COLLECTIONS.has(c)) {
-        const p = routes.imports?.()
-        return p ? { type: 'path', path: p } : null
-    }
-    if (c === 'nivaro_issues') {
-        const p = routes.issues?.()
-        return p ? { type: 'path', path: p } : null
-    }
-    // Any other system collection has no user-facing page — plain row, never a
-    // /collections/nivaro_* route that would 404 or 403.
-    if (/^nivaro_/i.test(c) || /^directus_/i.test(c)) return null
-
-    if (i) {
-        const p = routes.record(c, i)
-        return p ? { type: 'path', path: p } : null
-    }
-    const p = routes.list?.(c)
-    return p ? { type: 'path', path: p } : null
-}
+export declare function resolveCollectionIcon(iconName: string | null | undefined): React.ElementType | null;
+
+export declare function resolveNotificationTarget(collection: string | null | undefined, item: string | null | undefined, routes: NotificationRouteMap): NotificationTarget;
 
 export declare function RevisionsPanel({ collection, item, onRollback, triggerClassName, inlineTableFields, open, onOpenChange }: {
     collection: string;
@@ -1767,20 +2778,67 @@ export declare interface RoomInfo {
  */
 declare type RoomOpener = (room: string, label?: string) => void;
 
-/** Convenience: run a resolved target (navigate or open the chat room). */
-export declare function runNotificationTarget(
-target: NotificationTarget,
-navigate: (path: string) => void
-): boolean {
-    if (!target) return false
-    if (target.type === 'chat') {
-        openChatRoom(target.room)
-        return true
-    }
-    navigate(target.path)
-    return true
+export declare const ROW_HIGHLIGHT_TINTS: Record<string, {
+    row: string;
+    text: string;
+}>;
+
+/**
+ * A one-click rewrite of every row in the grid, driven by an aggregate of a
+ * related collection.
+ *
+ * EFP's "Close Out Lines" is one instance of this shape: for each REQ line,
+ * sum `open_unbilled_amount` across the PO lines pointing at it and, where the
+ * line covers that remainder, subtract it. Expressed as config rather than
+ * EFP code so any collection can do the same:
+ *
+ *   {label:'Close Out Lines', relation:'po_line_items',
+ *    aggregate:{field:'open_unbilled_amount', op:'sum'},
+ *    guard:'{{amount}} >= {{__agg__}}',
+ *    set:{amount:'{{amount}} - {{__agg__}}'}}
+ *
+ * `{{__agg__}}` is the aggregate for that row (same token match-agg-column
+ * uses); every other `{{field}}` reads the row's current value. Rows failing
+ * the guard are left exactly as they are.
+ *
+ * Writes go through the SAME paths a manual cell edit uses, so a staged grid
+ * (new record, addendum, save_mode 'pending') stages the change and an
+ * immediate grid PATCHes it — the action never invents its own persistence.
+ */
+declare interface RowBulkActionConfig {
+    label: string;
+    /** O2M alias on the ROW's collection pointing at the rows to aggregate. */
+    relation: string;
+    aggregate: {
+        field: string;
+        op?: 'sum' | 'count' | 'min' | 'max';
+    };
+    /** Optional per-row condition; rows that fail are skipped untouched. */
+    guard?: string;
+    /** field → formula. */
+    set: Record<string, string>;
+    confirm?: string;
+    variant?: 'default' | 'danger';
+}
+
+export declare function rowHighlightClass(color?: string | null): string | undefined;
+
+export declare function rowHighlightTextClass(color?: string | null): string;
+
+declare interface RowRule {
+    trigger_field?: string | null;
+    trigger_op?: string;
+    trigger_value?: string | null;
+    target_field: string;
+    target_type: 'set' | 'clear' | 'relation_field';
+    target_value?: string | null;
+    only_if_empty?: boolean;
+    sort?: number;
 }
 
+/** Convenience: run a resolved target (navigate or open the chat room). */
+export declare function runNotificationTarget(target: NotificationTarget, navigate: (path: string) => void): boolean;
+
 export declare type SectionState = {
     isCollapsed: (key: string) => boolean;
     toggle: (key: string) => void;
@@ -1791,20 +2849,27 @@ export declare type SectionState = {
 export declare function SelectField({ field, value, onChange, error, disabled, readOnly, inputId, errorId }: FieldComponentProps): JSX.Element;
 
 /**
- * rrweb session recorder for headless frontends.
+ * rrweb session recorder for headless frontends — two modes, one hook
+ * (the exact model the admin app runs; see admin/src/lib/use-session-recorder.ts).
+ *
+ * FULL mode (`session_recording_enabled` on the instance): events stream to
+ * the server continuously.
+ *
+ * ERROR-CLIP mode (`error_replay_enabled`, when full recording is off):
+ * rrweb records into a rolling IN-MEMORY buffer — two 30s checkout windows,
+ * so 30–60s of history — and uploads NOTHING. When the host reports an error,
+ * `captureErrorClip()` flushes the buffer as a short recording labelled
+ * app='error-clip'; attach the returned `recording_id`/`offset_ms` to your
+ * `POST /issues/client` body and the issue links straight to the replay.
  *
  * Drop `useSessionRecorder({ app: 'customer-portal' })` anywhere inside a
- * NivaroProvider (or pass a client explicitly) and the app records itself —
- * ONLY when the Nivaro instance has session recording enabled in Settings,
- * and ONLY if the host app has `rrweb` installed (optional peer dependency;
- * without it the hook warns once and no-ops).
+ * NivaroProvider (or pass a client explicitly). Needs `rrweb` installed in
+ * the host (optional peer dependency; without it the hook warns once and
+ * no-ops). Privacy in both modes: every input masked, `nvr-no-record`
+ * class blocked; in clip mode events never leave the browser except on error.
  *
- * Privacy defaults match the admin recorder: every input masked before
- * events leave the browser, elements with the `nvr-no-record` class blocked.
- * Events flush every 10s (or 150 events); the server enforces size caps and
- * a 7-day retention. Recordings attribute to the authenticated SDK identity
- * (usually your service token's user) with the `app` label telling replays
- * apart per frontend.
+ * `captureErrorClip` is a module singleton so an error boundary — a class
+ * component far from this hook — can call it without plumbing.
  */
 export declare interface SessionRecorderOptions {
     /** Label shown in the admin replay list — which frontend this is. */
@@ -1870,7 +2935,9 @@ export declare function TextField({ field, value, onChange, error, disabled, rea
 
 export declare function TipLayer(): ReactPortal | null;
 
-declare type TokenResolver = (path: string) => unknown;
+export declare function titleCase(str: string): string;
+
+export declare type TokenResolver = (path: string) => unknown;
 
 /** Install the listeners. Safe to call more than once. */
 export declare function trackActivity(): void;
@@ -1886,8 +2953,45 @@ export declare function translateScopeValues(client: {
     target_collection: string;
 }, ids: Array<string | number>, valueField?: string): Promise<Array<string | number>>;
 
+/**
+ * Base URL + auth for the few raw `fetch` calls (widgets, PDF blobs) that
+ * can't go through `client.request`. Derives everything from the ambient
+ * Nivaro client so external hosts (different origin, token auth) work the
+ * same as the same-origin admin; falls back to relative '/api' + cookies
+ * when no provider is mounted.
+ */
+export declare function useApiFetchConfig(): {
+    apiBase: string;
+    authHeaders: Record<string, string>;
+    credentials: RequestCredentials;
+};
+
 export declare function useApiUpdate(): ApiVersionInfo | null;
 
+export declare function useChannelAdmin(channelId: number | null): {
+    update: UseMutationResult<unknown, Error, {
+    name?: string;
+    topic?: string | null;
+    visibility?: "open" | "role" | "private";
+    role?: string | null;
+    is_archived?: boolean;
+    }, unknown>;
+    addMember: UseMutationResult<unknown, Error, string, unknown>;
+    removeMember: UseMutationResult<unknown, Error, string, unknown>;
+};
+
+/** Browsable channels — what keeps the sidebar to joined rooms only. */
+export declare function useChannelDirectory(search: string): {
+    channels: NoInfer<DirectoryChannel[]>;
+    loading: boolean;
+};
+
+/** Members of a channel — the owner-facing list for private channels. */
+export declare function useChannelMembers(channelId: number | null): {
+    members: NoInfer<ChannelMember[]>;
+    loading: boolean;
+};
+
 export declare function useChatConfig(): ChatConfig;
 
 export declare function useChatMessages(room: string | null): {
@@ -1895,6 +2999,13 @@ export declare function useChatMessages(room: string | null): {
     loading: boolean;
 };
 
+/** Id + name only — /api/roles is admin-gated, so the channel picker reads the
+ *  chat route's own lightweight list. */
+export declare function useChatRoles(): NoInfer<{
+    id: string;
+    name: string;
+}[]>;
+
 /**
  * The sidebar. The server decides WHICH rooms (visibility) and computes unread
  * in SQL against the watermark; the client only labels them. The old version
@@ -1908,8 +3019,48 @@ export declare function useChatRooms(): {
     loading: boolean;
 };
 
+/** Search every room in MY sidebar (server enforces visibility by
+ *  construction — the room set is the user's own). */
+export declare function useChatSearch(q: string): {
+    hits: NoInfer<ChatSearchHit[]>;
+    loading: boolean;
+};
+
+export declare function useCreateChannel(): UseMutationResult<unknown, Error, {
+name: string;
+key?: string;
+topic?: string;
+visibility?: "open" | "role" | "private";
+role?: string | null;
+}, unknown>;
+
+export declare function useCreateGroupDm(): UseMutationResult<    {
+room: string;
+name: string;
+}, Error, {
+user_ids: string[];
+name?: string;
+}, unknown>;
+
+export declare function useDeleteMessage(room: string): UseMutationResult<unknown, Error, number, unknown>;
+
 export declare function useDrilldown(): DrilldownContextValue | null;
 
+export declare function useEditMessage(room: string): UseMutationResult<unknown, Error, {
+messageId: number;
+text: string;
+}, unknown>;
+
+/**
+ * Resolves an entity room ('wf:CR26-76773') to the record's URL, host-routed
+ * via cfg.recordUrl. The room-type registry maps the prefix to a collection +
+ * match field; when the match field isn't the PK the record is looked up by
+ * it (readable by construction — room visibility already required record
+ * read). Null for non-entity rooms, unregistered prefixes, or when the record
+ * doesn't resolve.
+ */
+export declare function useEntityRoomLink(room: string | null): string | null;
+
 export declare function useFieldArray(form: UseNivaroFormReturn, field: string): FieldArrayReturn;
 
 export declare function useFieldState(form: UseNivaroFormReturn, field: string): FieldState;
@@ -2033,6 +3184,8 @@ export declare type UseNivaroFormReturn = {
     gridFlushersRef: default_2.MutableRefObject<Map<string, () => Promise<void>>>;
 };
 
+export declare function useOptionalNivaroClient(): NivaroClient | null;
+
 export declare function useOrderedLayout(form: UseNivaroFormReturn): {
     items: LayoutItem[];
     hasTabs: boolean;
@@ -2099,6 +3252,21 @@ export declare function useRelationOptions(client: NivaroClient | null, relatedC
     error: Error | null;
 };
 
+export declare function useRoomMembership(): {
+    join: UseMutationResult<unknown, Error, string, unknown>;
+    leave: UseMutationResult<unknown, Error, string, unknown>;
+    setMuted: UseMutationResult<unknown, Error, {
+    room: string;
+    muted: boolean;
+    }, unknown>;
+    setNotifyMode: UseMutationResult<unknown, Error, {
+    room: string;
+    mode: "all" | "mentions";
+    }, unknown>;
+};
+
+export declare function useRoomPins(room: string | null): NoInfer<PinnedMessage[]>;
+
 /** Stacked avatar cluster (+N) with a hover/pinnable portal roster whose rows
  *  are UserChips — the single user-display primitive for owners/user lists.
  *  Reused by the item-header Owners chip and the collection browser. */
@@ -2122,6 +3290,13 @@ export declare function useSessionRecorder(options?: SessionRecorderOptions): vo
 
 export declare function useTabState(form: UseNivaroFormReturn): TabState;
 
+export declare function useTogglePin(room: string): UseMutationResult<unknown, Error, number, unknown>;
+
+export declare function useToggleReaction(room: string): UseMutationResult<unknown, Error, {
+messageId: number;
+emoji: string;
+}, unknown>;
+
 export declare function useTypingIndicator(room: string | null): {
     onType: () => void;
     clearTyping: () => void;
@@ -2130,6 +3305,17 @@ export declare function useTypingIndicator(room: string | null): {
 
 export declare function useUnreadChirp(totalUnread: number, rooms?: RoomInfo[]): void;
 
+/** Directory of users to add to a private channel. */
+export declare function useUserSearch(search: string, enabled: boolean): {
+    users: NoInfer<{
+        id: string;
+        first_name: string | null;
+        last_name: string | null;
+        email: string | null;
+    }[]>;
+    loading: boolean;
+};
+
 export declare function useWatchFields(form: UseNivaroFormReturn, fields: string[]): Record<string, unknown>;
 
 /**
@@ -2149,6 +3335,32 @@ declare interface ValidationResult {
     unknownTokens: string[];
 }
 
+export declare function WidgetSlot({ widgetId, inputBindings, itemDraft, itemCollection, ready, label, defaultExpanded, frameless, apiBase: apiBaseProp, compact, strip, onClientAction, onWidgetType, onContentChange }: WidgetSlotProps): JSX.Element | null;
+
+declare interface WidgetSlotProps {
+    widgetId: number;
+    inputBindings?: InputBinding[];
+    itemDraft?: Record<string, unknown>;
+    itemCollection?: string;
+    ready?: boolean;
+    label?: string;
+    defaultExpanded?: boolean;
+    /** Render body only — no card border/header/collapse (host provides chrome). */
+    frameless?: boolean;
+    apiBase?: string;
+    compact?: boolean;
+    strip?: boolean;
+    onClientAction?: (action: ClientAction) => void;
+    onWidgetType?: (type: string) => void;
+    /**
+     * Reports whether the widget has anything to show (review_list: any rows;
+     * other types: any successful render; errors count as content so failures
+     * stay visible). Lets a host section's hide_when_empty consider widget
+     * content, not just field values.
+     */
+    onContentChange?: (hasContent: boolean) => void;
+}
+
 export declare function WorkflowPanel({ collection, item }: {
     collection: string;
     item: string;