@nivaro/react 0.1.286 → 0.1.288

package/dist/index.d.ts

@@ -1211,6 +1211,8 @@ export declare function deriveGroupKey<T extends QueueGroupingRow>(row: T, attri
 
 export declare function describeCron(cron: string): string;
 
+declare type DetailTab = 'calls' | 'submissions' | 'obligations' | 'contracts';
+
 declare type DigestFrequency = 'instant' | 'daily' | 'weekly';
 
 declare type DimensionCascadeRule = {
@@ -1321,6 +1323,33 @@ export declare function ErpFailureBanner({ collection, itemId }: {
     itemId: string;
 }): JSX.Element | null;
 
+/**
+ * One outbound submission — status, endpoint, reference, and on expand the
+ * stored request/response plus every attempt. Shared by the record header's
+ * External requests dialog and the Integrations console's partner detail.
+ */
+export declare interface ErpSubmission {
+    id: number;
+    external_api: number | null;
+    external_api_name?: string | null;
+    external_ref: string | null;
+    status: string;
+    attempts: number;
+    last_error: string | null;
+    endpoint_path: string | null;
+    payload: unknown;
+    response: unknown;
+    created_at: string;
+    updated_at: string;
+    collection: string;
+    item: string;
+    /** The record's friendly (human-facing) id — present only where the
+     *  caller batch-resolved it (the partner detail's cross-record listing).
+     *  A record page hosting its OWN External requests dialog already IS that
+     *  record, so it never needs this badge and doesn't send it. */
+    record_label?: string;
+}
+
 export declare interface ErrorReplayLink {
     recording_id: string;
     /** Milliseconds into the recording where the error happened. Null for
@@ -1358,6 +1387,37 @@ export declare interface EvaluateOptions {
     missing?: 'zero' | 'null';
 }
 
+/** Which way an integration event travels: a partner calling in, a push we
+ *  sent out, or a poll we made of the partner. */
+declare type EventDirection = 'in' | 'out' | 'poll';
+
+/**
+ * One integration event opened into its full chain: the call, cron, import
+ * or feed that started it, every write and transition it caused, the flows
+ * that ran and the partner pushes that went out — as a tree. Opens on the
+ * first failure, expanded and scrolled to.
+ */
+export declare function EventPathSheet({ target, event, onClose, onOpenRecord, onOpenEvent }: EventPathSheetProps): JSX.Element | null;
+
+export declare interface EventPathSheetProps {
+    /** An event (`source` + `id`, optionally read through its `record`), or a
+     *  chain opened directly by id — where a replay link leads. */
+    target: IntegrationEventPathTarget | null;
+    event?: {
+        label?: string | null;
+        item_label?: string | null;
+    } | null;
+    onClose: () => void;
+    onOpenRecord?: (collection: string, id: string) => void;
+    /** Replay links — the chain this one replayed, or a replay of it. The host
+     *  swaps the sheet's target to `{ chainId }`. Absent = the links read as text. */
+    onOpenEvent?: (target: {
+        chainId: string;
+    }) => void;
+}
+
+declare type EventStatus = 'ok' | 'error' | 'info';
+
 export declare type ExprNode = {
     kind: 'number';
     value: number;
@@ -1618,6 +1678,16 @@ declare interface FilterOptionSpec {
  * (ids → names), ≥/≤ for ranges, first two entries + count for multiselects. */
 export declare function filterValueDisplay(def: FilterDef, value: string | string[]): string;
 
+export declare function FirefightView({ onOpenRecord, onJumpTab, focusSignal }: FirefightViewProps): JSX.Element;
+
+export declare interface FirefightViewProps {
+    onOpenRecord?: (collection: string, id: string) => void;
+    /** Move to another console tab, carrying context (e.g. `{ apiId }`). */
+    onJumpTab?: (tab: string, context?: Record<string, unknown>) => void;
+    /** Expand this signal on first load (a notification deep link). */
+    focusSignal?: string;
+}
+
 export declare function FirstLoginChecklist({ profileUrl }: {
     profileUrl?: string;
 }): JSX.Element | null;
@@ -1973,6 +2043,11 @@ export declare interface ImportConsoleProps {
 
 export declare type ImportConsoleTab = 'runs' | 'collection' | 'definitions';
 
+/** The instance-wide default cadence — header of the imports table. */
+export declare function ImportDefaultCadenceControl({ className }: {
+    className?: string;
+}): JSX.Element;
+
 export declare interface ImportDefinition {
     id: number;
     key: string;
@@ -2044,6 +2119,32 @@ export declare function ImportFromFileButton({ collection, templateFilter, getLa
     compact?: boolean;
 }): JSX.Element | null;
 
+declare interface ImportHealth {
+    rows: ImportHealthRow[];
+    default_hours: number;
+}
+
+/**
+ * Per-import staleness — how often each staged import is expected to succeed
+ * before it counts as stale. ONE store (the stale-import signal's settings:
+ * `default_hours` and `cadence_hours:<import key>`, 0 = not monitored) and
+ * ONE query key, so the Import Console and the Integrations console always
+ * show the same value: an edit in either refreshes both.
+ */
+export declare interface ImportHealthRow {
+    key: string;
+    label: string;
+    is_active: boolean;
+    last_status: string | null;
+    last_run_at: string | null;
+    last_ok_at: string | null;
+    failures7d: number;
+    /** Expected hours between successes; 0 when not monitored or dormant. */
+    cadence_hours: number;
+    cadence_source: 'default' | 'override' | 'excluded' | 'dormant';
+    stale: boolean;
+}
+
 declare type ImportIssue = ImportParseResponse['issues'][number];
 
 export declare function ImportIssuesPanel({ issues, onDismiss }: {
@@ -2145,6 +2246,22 @@ export declare interface ImportRun {
 /** Shared types for the Import Console (`/api/staged-imports`). */
 export declare type ImportRunStatus = 'queued' | 'running' | 'completed' | 'error' | 'canceled';
 
+/** The chip a definitions list shows beside each import. */
+export declare function ImportStalenessChip({ importKey }: {
+    importKey: string;
+}): JSX.Element | null;
+
+export declare function ImportStalenessControl({ importKey, label, compact, className }: ImportStalenessControlProps): JSX.Element;
+
+export declare interface ImportStalenessControlProps {
+    /** The import definition's key; absent for a definition that isn't saved yet. */
+    importKey?: string | null;
+    label?: string;
+    /** Table-cell size: the state opens its editor in a popover beside it. */
+    compact?: boolean;
+    className?: string;
+}
+
 /** Live queue depth is never windowed; the rest respects `window_days`. */
 export declare interface ImportStats {
     window_days: number;
@@ -2190,6 +2307,19 @@ export declare function InboundCallersView({ hours: initialHours }: {
     hours?: number;
 }): JSX.Element;
 
+/**
+ * Inbound: health first — the host's own live queue (an ingest backlog, say), then whether
+ * scheduled imports are arriving on time — and investigation last, since who
+ * called in and exactly what they sent is what you reach for once something
+ * above already looks wrong, not on every visit.
+ */
+export declare function InboundView({ extra }: InboundViewProps): JSX.Element;
+
+export declare interface InboundViewProps {
+    /** Host content rendered after the shared sections (a deployment's own queues). */
+    extra?: ReactNode;
+}
+
 export declare function InlineTableField({ relatedCollection, manyField, parentId, parentCollection, layoutId, showRowRevisions, rowComments, allowRevisionRestore, saveMode, showLineNumbers, enableReorder, parentCascades, rowRules, columnPresets, defaultPreset, drawerRelations, parentContextFields, uniqueBy, sortField, sortDir, sectionGroupBy, freezeFirstColumn, rowFilter, rowDefaults, allocateDrawer, autoAllocate, rowBulkActions, uploadTemplate, rowMatchPanel, lineSla, rowLints, stats, compareSeries, sumCap, spreadRemaining, submissionErrors, prefillParentId, parentFieldKey, readOnly, emptyLabel, editorMode }: {
     relatedCollection: string;
     manyField: string;
@@ -2288,6 +2418,12 @@ declare interface InputBinding {
     binding_value: string;
 }
 
+export declare type IntegrationActionResult = {
+    key: string;
+    ok: boolean;
+    message: string;
+};
+
 export declare function IntegrationDots({ rows, className }: IntegrationDotsProps): JSX.Element;
 
 export declare interface IntegrationDotsProps {
@@ -2298,6 +2434,63 @@ export declare interface IntegrationDotsProps {
     className?: string;
 }
 
+/**
+ * One entry of the integration events feed. The cross-record feed carries
+ * `provider`; the per-record feed (GET /integration-events/record/...) carries
+ * `source` instead — read `provider ?? source` for the source id.
+ */
+declare interface IntegrationEvent {
+    id: string | number;
+    label: string;
+    text: string;
+    user?: string | null;
+    created_at: string;
+    context?: string | null;
+    /** Null when the event concerns no single record (a whole import, a poll). */
+    collection: string | null;
+    item_id: string | null;
+    item_label?: string | null;
+    provider?: string;
+    source?: string;
+    direction?: EventDirection;
+    chain_id?: string | null;
+    /** How many records the event touched, when it is more than one. */
+    record_count?: number;
+    partner?: string | null;
+    caller?: string | null;
+    replayable?: boolean;
+    status?: EventStatus | null;
+}
+
+export declare interface IntegrationEventPath {
+    root: IntegrationPathNode;
+    mode: 'exact' | 'inferred';
+    truncated: boolean;
+    step_count: number;
+    /** Key of the first failed step, if any. */
+    first_failure: string | null;
+    replay_of: string | null;
+    replayed_as: string[];
+    /** Steps left out because the viewer may not read their records. */
+    hidden_steps?: number;
+    warnings: string[];
+}
+
+/** Which event to open a path for. With `record`, the path is read through
+ *  the record-scoped route (any user who can read the record); without, the
+ *  admin console route. `{ chainId }` opens one chain directly — what a
+ *  replay link carries (admin route). */
+export declare type IntegrationEventPathTarget = {
+    source: string;
+    id: string;
+    record?: {
+        collection: string;
+        item: string;
+    };
+} | {
+    chainId: string;
+};
+
 export declare function IntegrationObligationsView({ api, className }: IntegrationObligationsViewProps): JSX.Element;
 
 export declare interface IntegrationObligationsViewProps {
@@ -2307,6 +2500,123 @@ export declare interface IntegrationObligationsViewProps {
     className?: string;
 }
 
+export declare interface IntegrationPartnerCard {
+    id: number;
+    name: string;
+    enabled: boolean;
+    health: IntegrationPartnerHealth;
+    calls24: number;
+    success_pct24: number | null;
+    success_pct7d: number | null;
+    p50_ms: number | null;
+    p95_ms: number | null;
+    last_ok_at: string | null;
+    last_fail_at: string | null;
+    last_fail_reason: string | null;
+    hourly: Array<{
+        hour: string;
+        ok: number;
+        failed: number;
+    }>;
+    flags: {
+        test_endpoint: boolean;
+        mock: boolean;
+        auth_failing: boolean;
+    };
+    owner: {
+        id: string;
+        name: string;
+    } | null;
+    obligations: {
+        sent: number;
+        pending: number;
+        failed: number;
+        missing: number;
+        overdue: number;
+    };
+}
+
+export declare interface IntegrationPartnerDetail {
+    card: IntegrationPartnerCard;
+    calls: PartnerCall[];
+    contracts: PartnerContract[];
+}
+
+export declare type IntegrationPartnerHealth = 'healthy' | 'degraded' | 'failing' | 'idle';
+
+export declare interface IntegrationPartnersSummary {
+    calls24: number;
+    success_pct24: number | null;
+    not_healthy: number;
+}
+
+/** What a step opens to: field changes, a push, a partner call, a flow run,
+ *  a transition. */
+export declare type IntegrationPathDetail = {
+    type: 'changes';
+    changes: Array<{
+        field: string;
+        label: string;
+        old: string;
+        new: string;
+    }>;
+} | {
+    type: 'push';
+    status: string;
+    http_status?: number | null;
+    attempts?: number;
+    error?: string | null;
+    request?: string | null;
+    response?: string | null;
+    submission_id: number;
+} | {
+    type: 'call';
+    method: string;
+    url: string;
+    status?: number | null;
+    duration_ms?: number | null;
+    error?: string | null;
+} | {
+    type: 'flow';
+    status: string;
+    halted_at?: string | null;
+    error?: string | null;
+} | {
+    type: 'transition';
+    from?: string | null;
+    to?: string | null;
+    comment?: string | null;
+};
+
+/** One step of an event's path, with the steps it set off under it. */
+export declare interface IntegrationPathNode {
+    /** e.g. 'activity:12' */
+    key: string;
+    /** Parent step key; null = the root. */
+    parent: string | null;
+    kind: PathStepKind;
+    /** ISO timestamp. */
+    at: string;
+    /** Milliseconds after the root step. */
+    offset_ms: number;
+    who?: string | null;
+    record?: {
+        collection: string;
+        item: string;
+        label?: string | null;
+    } | null;
+    summary: string;
+    failed?: boolean;
+    inferred?: boolean;
+    /** Why it was matched (inferred) or why it failed. */
+    reason?: string | null;
+    detail?: IntegrationPathDetail | null;
+    api_id?: number | null;
+    children: IntegrationPathNode[];
+    /** The folded steps of a 'group' node. */
+    members?: IntegrationPathNode[];
+}
+
 /** The filter-pill set the collection browser offers (its own conditions[]
  *  round trip to `/items/:collection` — the queue has no equivalent server
  *  path, so it gets the column but not the filter). Values are the same
@@ -2317,6 +2627,98 @@ export declare const INTEGRATIONS_FILTER_OPTIONS: {
     label: string;
 }[];
 
+/**
+ * The Integrations console: everything that talks to an outside system on one
+ * page, in the order an operator asks — what is broken now (Firefight), how
+ * each partner is doing (Partners), what the partners reported (Events), who
+ * is calling us (Inbound). Hosts add their own tabs through `extraTabs`.
+ */
+export declare function IntegrationsConsole({ extraTabs, tab, onTabChange, onOpenRecord, focusSignal, inboundExtra, className }: IntegrationsConsoleProps): JSX.Element;
+
+export declare interface IntegrationsConsoleProps {
+    /** Host tabs, inserted after Events (e.g. a deployment's own integrations). */
+    extraTabs?: IntegrationsConsoleTab[];
+    /** Controlled tab — pair with onTabChange to keep it in the URL. */
+    tab?: string;
+    onTabChange?: (key: string) => void;
+    onOpenRecord?: (collection: string, id: string) => void;
+    /** Expand this Firefight signal on first load. */
+    focusSignal?: string;
+    /** Host content rendered at the end of the Inbound tab (a deployment's own queues). */
+    inboundExtra?: ReactNode;
+    className?: string;
+}
+
+export declare interface IntegrationsConsoleTab {
+    key: string;
+    label: string;
+    render: () => ReactNode;
+}
+
+/**
+ * HTTP shapes served by GET /integration-signals and /integration-partners —
+ * copied from the core routes so the shared package never imports api code.
+ */
+export declare interface IntegrationSignalAction {
+    kind: 'retry_submission' | 'resend' | 'open' | 'explain' | 'extension';
+    label: string;
+    /** Extension action id (kind 'extension'), submission id (retry). */
+    id?: string;
+    payload?: Record<string, unknown>;
+}
+
+export declare interface IntegrationSignalRow {
+    key: string;
+    group?: string;
+    group_label?: string;
+    title: string;
+    detail?: string;
+    since?: string;
+    /** Identity of THIS occurrence (a run id, a submission attempt...) — what
+     *  Dismiss keys on, distinct from `key` (the problem itself). */
+    occurrence?: string;
+    api?: string;
+    record?: {
+        collection: string;
+        id: string;
+        label?: string;
+    };
+    actions: IntegrationSignalAction[];
+    /** What opens in place under this row — the failed push, the import run. */
+    drill?: SignalDrill;
+    /** When the snapshot first saw this problem. */
+    first_seen: string;
+    /** Present only on rows in `snoozed`. */
+    snooze?: RowSnooze;
+}
+
+export declare interface IntegrationSignalsSnapshot {
+    checked_at: string | null;
+    stale: boolean;
+    signals: IntegrationSignalView[];
+}
+
+export declare interface IntegrationSignalView {
+    id: string;
+    label: string;
+    description: string;
+    tab: string;
+    severity: 'critical' | 'warn';
+    count: number;
+    error: string | null;
+    last_run: string | null;
+    thresholds: SignalThreshold[];
+    settings: {
+        enabled: boolean;
+        severity: 'critical' | 'warn';
+        thresholds: Record<string, number>;
+    };
+    rows: IntegrationSignalRow[];
+    snoozed: IntegrationSignalRow[];
+    /** Rows actually returned (the evaluator may count more than it lists). */
+    shown: number;
+}
+
 export declare function IntegrationStatusBanner({ collection, itemId }: IntegrationStatusBannerProps): JSX.Element | null;
 
 /**
@@ -3403,6 +3805,69 @@ declare interface ParseSuccess {
     tokens: string[];
 }
 
+/**
+ * One row of Partner detail's Recent calls list (GET /integration-partners/:id).
+ * `source: 'log'` carries a real body to open (GET .../calls/:callId);
+ * `'outbound'` is the always-on counter row for a call that never landed one
+ * (before Task 15's extension-call fix, or any caller still passing no
+ * `_log`) — it opens to "nothing recorded", never a fetch.
+ */
+declare interface PartnerCall {
+    key: string;
+    id: number;
+    source: 'log' | 'outbound';
+    created_at: string;
+    method: string | null;
+    path: string | null;
+    status: number | null;
+    ok: boolean | number;
+    duration_ms: number | null;
+    error: string | null;
+    triggered_by: string | null;
+    has_body: boolean;
+    user: PartnerCallUser | null;
+}
+
+/** One user recorded on a call — via nivaro_users, batch-resolved server-side
+ *  through the same helper the push drill-down uses, so a suspended or
+ *  machine account carries the same `inactive`/`account_kind` facts here as
+ *  it does on a `Requester` elsewhere in the console. */
+declare interface PartnerCallUser {
+    id: string;
+    name: string;
+    email: string | null;
+    /** 'suspended' / 'inactive' / 'redacted' — a person who can no longer act. */
+    inactive: string | null;
+    /** integration | bot | service | placeholder — never a person. */
+    account_kind: string | null;
+}
+
+declare interface PartnerContract {
+    endpoint_id: number;
+    name: string;
+    last_run: string | null;
+    ok: boolean | number | null;
+    detail: string | null;
+}
+
+export declare function PartnerDetail({ apiId, onClose, initialTab }: PartnerDetailProps): JSX.Element;
+
+export declare interface PartnerDetailProps {
+    apiId: number;
+    onClose: () => void;
+    initialTab?: DetailTab;
+}
+
+export declare function PartnersView({ openId, onOpenChange }?: PartnersViewProps): JSX.Element;
+
+export declare interface PartnersViewProps {
+    /** Detail sheet open on this partner (controlled by the frame). */
+    openId?: number | null;
+    onOpenChange?: (id: number | null) => void;
+}
+
+declare type PathStepKind = 'request' | 'cron' | 'import' | 'feed' | 'write' | 'transition' | 'flow' | 'push' | 'attempt' | 'partner_call' | 'group';
+
 declare interface PendingTask {
     title: string;
     assignee: string | null;
@@ -4031,6 +4496,9 @@ export declare interface QuickPickerProps {
     className?: string;
 }
 
+/** Critical first, then the problem that has been open longest. */
+export declare function rankSignals(signals: IntegrationSignalView[]): IntegrationSignalView[];
+
 /**
  * Tier a team against a cell's filter values. `out` carries the human
  * mismatches ("doesn't cover BLT"). Filters without a resolvable id don't
@@ -4548,6 +5016,9 @@ declare interface Row {
      *  ObligationTrigger union into this client lib for one comparison, so a
      *  new trigger kind added server-side never breaks this file's build. */
     trigger?: string;
+    /** The kind's human label from the registry ("Fusion — transfer order
+     *  submitted"); null when the server no longer knows the kind. */
+    label?: string | null;
 }
 
 export declare const ROW_HIGHLIGHT_TINTS: Record<string, {
@@ -4666,6 +5137,16 @@ declare interface RowRule {
     sort?: number;
 }
 
+declare interface RowSnooze {
+    id: number;
+    until: string | null;
+    until_change: boolean;
+    /** true = this snooze is a Dismiss — "seen this one, tell me when it
+     *  happens again" — never a group/signal scope, always row-only. */
+    until_occurrence: boolean;
+    note: string | null;
+}
+
 /**
  * Real-user monitoring collector. Hand-rolled (no web-vitals dep): one 'load'
  * event per page load (TTFB / FCP / LCP / total) once LCP settles, plus one
@@ -4685,6 +5166,8 @@ export declare function rumRouteChange(pathname: string): void;
  *  a foreign-app URL in a new tab). */
 export declare function runNotificationTarget(target: NotificationTarget, navigate: (path: string) => void): boolean;
 
+declare type Scope = 'row' | 'group' | 'signal';
+
 declare interface ScopeDimensionLite {
     name: string;
     label: string;
@@ -4781,6 +5264,34 @@ declare interface SheetItem {
     url: string;
 }
 
+export declare function SignalCard({ signal, expanded, onToggle, onOpenRecord, onExplain, canExplain }: SignalCardProps): JSX.Element;
+
+export declare interface SignalCardProps {
+    signal: IntegrationSignalView;
+    expanded: boolean;
+    onToggle: () => void;
+    onOpenRecord?: (collection: string, id: string) => void;
+    /** An 'explain' action — the frame decides where it leads. */
+    onExplain?: (action: IntegrationSignalAction, row: IntegrationSignalRow) => void;
+    /** False hides an explain action the host has nowhere to open. */
+    canExplain?: (action: IntegrationSignalAction) => boolean;
+}
+
+/** A typed "Details" reference on a signal row (GET /integration-signals). */
+declare interface SignalDrill {
+    kind: 'submission' | 'import_run' | (string & {});
+    id: string;
+}
+
+declare interface SignalThreshold {
+    key: string;
+    label: string;
+    default: number;
+    unit: string;
+    min?: number;
+    max?: number;
+}
+
 declare type SkipCondition = {
     type: 'no_owners';
 } | {
@@ -4844,6 +5355,38 @@ export declare type SlotRendererProps = {
     defaultExpanded: boolean;
 };
 
+export declare interface SnoozeInput {
+    signal: string;
+    row_key?: string;
+    group_key?: string;
+    until?: string | null;
+    until_change?: boolean;
+    /** A Dismiss — hides this ONE row until its occurrence changes. Row-scoped
+     *  only; never combine with group_key. */
+    until_occurrence?: boolean;
+    note?: string;
+}
+
+/**
+ * Quiet one problem, a whole group, or the whole signal. "Until it changes"
+ * is offered only for a single row — the API hashes ONE row's payload, so a
+ * group or signal can only be quieted for a set time. Dismiss lives at the
+ * top for a row-scoped menu — the one-click, no-questions-asked cousin of
+ * everything below it.
+ */
+export declare function SnoozeMenu({ signal, signalLabel, rowKey, group, defaultScope, compact }: {
+    signal: string;
+    signalLabel: string;
+    rowKey?: string;
+    group?: {
+        key: string;
+        label: string;
+    };
+    /** What the menu opens on — a group header opens on the group. */
+    defaultScope?: Scope;
+    compact?: boolean;
+}): JSX.Element;
+
 export declare function splitMessageTokens(text: string, entityPattern: string): MessageToken[];
 
 declare type SpreadPreset = 'even' | 'front' | 'back' | 'shape';
@@ -4860,6 +5403,20 @@ export declare function startRum(opts?: {
     apiBase?: string;
 }): void;
 
+export declare function SubmissionRow({ sub, onRetry, retrying, onShowPath }: {
+    sub: ErpSubmission;
+    onRetry: (id: number) => void;
+    retrying: boolean;
+    /** Opens the full integration path (write → transition → push → reply)
+     *  behind this submission. Absent = no "Show path" action. */
+    onShowPath?: (id: number) => void;
+}): JSX.Element;
+
+/** A submission / attempt status, as a small tinted chip. */
+export declare function SubmissionStatusPill({ status }: {
+    status: string;
+}): JSX.Element;
+
 /**
  * The one subscription editor — create + edit for nivaro_notification_subscriptions,
  * shared by the profile's Notifications & alerts card and the My Subscriptions
@@ -5148,6 +5705,9 @@ export declare function useElapsedLoading(loading: boolean, thresholdMs?: number
  */
 export declare function useEntityRoomLink(room: string | null): string | null;
 
+/** One event's full chain of writes. */
+export declare function useEventPath(target: IntegrationEventPathTarget | null): UseQueryResult<NoInfer<IntegrationEventPath | null>, Error>;
+
 export declare function useFeatureFlag(key: string): boolean;
 
 /**
@@ -5202,6 +5762,8 @@ export declare function useFormStatus(form: UseNivaroFormReturn): FormStatus;
 
 export declare function useGridFlush(): GridFlushContextValue | null;
 
+export declare function useImportHealth(): UseQueryResult<NoInfer<ImportHealth>, Error>;
+
 export declare function useItemEditAuth(): ItemEditAuthContextValue;
 
 export declare function useItemLock(collection: string | undefined, item: string | undefined, enabled: boolean): {
@@ -5346,6 +5908,13 @@ export declare function useOverlayState<T>(key: string): {
     back: (steps?: number) => void;
 };
 
+export declare function usePartner(id: number | null): UseQueryResult<NoInfer<IntegrationPartnerDetail>, Error>;
+
+export declare function usePartners(): UseQueryResult<NoInfer<{
+summary: IntegrationPartnersSummary;
+partners: IntegrationPartnerCard[];
+}>, Error>;
+
 export declare function usePeerReadAt(room: string | null): string | null;
 
 /**
@@ -5386,6 +5955,15 @@ export declare function UserChip({ userId, size }: {
     size?: 'default' | 'compact';
 }): React_2.JSX.Element;
 
+/** Integration events about one record, newest first, one page at a time. */
+export declare function useRecordIntegrationActivity(collection: string, item: string, page: number): UseQueryResult<NoInfer<{
+entries: IntegrationEvent[];
+page: number;
+has_more: boolean;
+}>, Error>;
+
+export declare function useRefreshSignals(): UseMutationResult<unknown, Error, void, unknown>;
+
 /**
  * Fetch selectable options for a relation field's related collection.
  * Re-fetches when `search` changes. Pass `enabled: false` to skip fetching
@@ -5444,6 +6022,22 @@ attachments?: string[];
 
 export declare function useSessionRecorder(options?: SessionRecorderOptions): void;
 
+/** Write one staleness setting: a number of hours, 0 (not monitored) or null (back to default). */
+export declare function useSetImportCadence(): UseMutationResult<unknown, Error, Record<string, number | null>, unknown>;
+
+export declare function useSignalAction(): UseMutationResult<IntegrationActionResult[], Error, {
+signal: string;
+row_keys: string[];
+action: IntegrationSignalRow["actions"][number];
+}, unknown>;
+
+export declare function useSignals(tab?: string): UseQueryResult<NoInfer<IntegrationSignalsSnapshot>, Error>;
+
+export declare function useSnooze(): {
+    add: UseMutationResult<unknown, Error, SnoozeInput, unknown>;
+    remove: UseMutationResult<unknown, Error, number, unknown>;
+};
+
 /** Mutations for the user's own subscriptions. Invalidates BOTH readers —
  *  the flat list (My Subscriptions) and the profile's sources aggregate. */
 export declare function useSubscriptionMutations(): {