@nivaro/react 0.1.287 → 0.1.288

package/dist/index.d.ts

@@ -1387,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;
@@ -2403,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 {
@@ -2462,6 +2550,73 @@ export declare interface IntegrationPartnersSummary {
     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
@@ -3711,6 +3866,8 @@ export declare interface PartnersViewProps {
     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;
@@ -4859,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, {
@@ -5243,10 +5403,13 @@ export declare function startRum(opts?: {
     apiBase?: string;
 }): void;
 
-export declare function SubmissionRow({ sub, onRetry, retrying }: {
+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. */
@@ -5542,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;
 
 /**
@@ -5789,6 +5955,13 @@ 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>;
 
 /**