@nivaro/react 0.1.285 → 0.1.287

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
@@ -1421,15 +1450,16 @@ 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
+ * sent — badge counts by outcome, click for the full request/response log
+ * (each request drills into every attempt). Always renders: a skeleton while
+ * loading, a quiet 'No external requests' when nothing was sent. 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;
+}): JSX.Element;
 
 /** Field paths an expression reads, without evaluating it. */
 export declare function extractExpressionTokens(src: string): string[];
@@ -1617,6 +1647,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;
@@ -1972,6 +2012,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;
@@ -2043,6 +2088,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 }: {
@@ -2144,6 +2215,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;
@@ -2189,6 +2276,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;
@@ -2287,6 +2387,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 {
@@ -2306,6 +2412,56 @@ 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;
+}
+
 /** 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
@@ -2316,6 +2472,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;
 
 /**
@@ -3402,6 +3650,67 @@ 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 interface PendingTask {
     title: string;
     assignee: string | null;
@@ -4030,6 +4339,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
@@ -4665,6 +4977,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
@@ -4684,6 +5006,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;
@@ -4780,6 +5104,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';
 } | {
@@ -4843,6 +5195,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';
@@ -4859,6 +5243,17 @@ export declare function startRum(opts?: {
     apiBase?: string;
 }): void;
 
+export declare function SubmissionRow({ sub, onRetry, retrying }: {
+    sub: ErpSubmission;
+    onRetry: (id: number) => void;
+    retrying: boolean;
+}): 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
@@ -5201,6 +5596,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): {
@@ -5345,6 +5742,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;
 
 /**
@@ -5385,6 +5789,8 @@ export declare function UserChip({ userId, size }: {
     size?: 'default' | 'compact';
 }): React_2.JSX.Element;
 
+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
@@ -5443,6 +5849,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(): {