@revenexx/studio-integrations 1.1.1 → 1.3.0

package/dist/runtime/components/Integrations/NodeVersionMoveDialog.vue

@@ -0,0 +1,133 @@
+<script setup>
+import { computed, ref, watch } from "vue";
+import {
+  AlertDialog,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  Button
+} from "@revenexx/studio";
+import { executableVersionsOf, findManifest, newestExecutableVersion } from "../../data/integrationNodeCatalog";
+import { planVersionMove } from "../../data/nodeVersionMove";
+import { resolveLocalized } from "../../utils/localize";
+const open = defineModel("open", { type: Boolean, ...{ default: false } });
+const props = defineProps({
+  node: { type: [Object, null], required: true }
+});
+const emit = defineEmits(["move"]);
+const t = useIntegrationsT();
+const versions = computed(() => props.node ? executableVersionsOf(props.node.nodeSlug) : []);
+const target = ref("");
+watch(open, (isOpen) => {
+  if (!isOpen || !props.node) return;
+  const newest = newestExecutableVersion(props.node.nodeSlug);
+  target.value = newest && newest !== props.node.nodeVersion ? newest : props.node.nodeVersion;
+});
+const plan = computed(() => {
+  const n = props.node;
+  if (!n) return null;
+  return planVersionMove(
+    findManifestExact(n.nodeSlug, n.nodeVersion),
+    findManifestExact(n.nodeSlug, target.value),
+    n.config
+  );
+});
+function findManifestExact(slug, version) {
+  const m = findManifest(slug, version);
+  return m && m.version === version ? m : null;
+}
+const unchanged = computed(() => !props.node || target.value === props.node.nodeVersion);
+function labelOf(entry) {
+  return resolveLocalized(entry.field?.label) || entry.key;
+}
+function confirm() {
+  const p = plan.value;
+  if (!props.node || !p || unchanged.value) return;
+  emit("move", { version: target.value, config: p.nextConfig });
+  open.value = false;
+}
+</script>
+
+<template>
+  <AlertDialog :open="open" @update:open="(v) => {
+  if (!v) open = false;
+}">
+    <AlertDialogContent>
+      <AlertDialogHeader>
+        <AlertDialogTitle>{{ t("integration.nodeInspector.version.move.title") }}</AlertDialogTitle>
+        <AlertDialogDescription>
+          {{ t("integration.nodeInspector.version.move.description") }}
+        </AlertDialogDescription>
+      </AlertDialogHeader>
+
+      <div v-if="props.node && plan" class="space-y-3 text-sm">
+        <div class="flex items-center gap-2">
+          <span class="tabular-nums text-muted-foreground">v{{ props.node.nodeVersion }}</span>
+          <span aria-hidden="true">→</span>
+          <select
+            v-model="target"
+            class="rounded border border-black/10 bg-white px-1.5 py-0.5 tabular-nums"
+            :aria-label="t('integration.nodeInspector.version.move.targetAria')"
+          >
+            <option v-for="m in versions" :key="m.version" :value="m.version">
+              v{{ m.version }}
+            </option>
+          </select>
+        </div>
+
+        <!-- A version the catalogue no longer carries cannot be compared against,
+             so the lists below are what arrives rather than what was checked. Said
+             once, here, instead of marking every setting as suspect. -->
+        <p v-if="!plan.comparable" class="text-amber-600">
+          {{ t("integration.nodeInspector.version.move.notComparable", { version: props.node.nodeVersion }) }}
+        </p>
+
+        <p v-if="unchanged" class="text-muted-foreground">
+          {{ t("integration.nodeInspector.version.move.same") }}
+        </p>
+
+        <template v-else>
+          <p v-if="plan.lossless" class="text-muted-foreground">
+            {{ t("integration.nodeInspector.version.move.lossless") }}
+          </p>
+
+          <div v-if="plan.dropped.length">
+            <p class="font-medium">{{ t("integration.nodeInspector.version.move.dropped") }}</p>
+            <ul class="mt-0.5 list-disc pl-5 text-muted-foreground">
+              <li v-for="e in plan.dropped" :key="e.key">
+                {{ labelOf(e) }}
+                <!-- The key, where it is not already the whole label. A setting no
+                     version declares any more has nothing but its key to go by, and
+                     printing that twice reads as a bug rather than as precision. -->
+                <span v-if="labelOf(e) !== e.key" class="text-xs">({{ e.key }})</span>
+              </li>
+            </ul>
+          </div>
+
+          <div v-if="plan.review.length">
+            <p class="font-medium">{{ t("integration.nodeInspector.version.move.review") }}</p>
+            <ul class="mt-0.5 list-disc pl-5 text-muted-foreground">
+              <li v-for="e in plan.review" :key="e.key">
+                {{ labelOf(e) }}
+                <span class="text-xs">
+                  ({{ e.reason === "nowRequired" ? t("integration.nodeInspector.version.move.reason.nowRequired") : t("integration.nodeInspector.version.move.reason.changed") }})
+                </span>
+              </li>
+            </ul>
+          </div>
+        </template>
+      </div>
+
+      <AlertDialogFooter>
+        <Button variant="outline" @click="open = false">
+          {{ t("integration.common.action.cancel") }}
+        </Button>
+        <Button :disabled="unchanged" @click="confirm">
+          {{ t("integration.nodeInspector.version.move.confirm") }}
+        </Button>
+      </AlertDialogFooter>
+    </AlertDialogContent>
+  </AlertDialog>
+</template>

package/dist/runtime/components/Integrations/NodeVersionMoveDialog.vue.d.ts

@@ -0,0 +1,21 @@
+import type { WorkflowNode } from '../../types/integrations.js';
+type __VLS_Props = {
+    node: WorkflowNode | null;
+};
+type __VLS_PublicProps = __VLS_Props & {
+    'open'?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    move: (payload: {
+        version: string;
+        config: Record<string, unknown>;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    onMove?: ((payload: {
+        version: string;
+        config: Record<string, unknown>;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/Integrations/RunActionsMenu.vue

@@ -10,6 +10,7 @@ import {
   DropdownMenuTrigger
 } from "@revenexx/studio";
 import { toast } from "vue-sonner";
+import { errorReason } from "../../utils/apiError";
 const props = defineProps({
   run: { type: Object, required: true }
 });
@@ -78,7 +79,7 @@ async function runAction(a) {
     );
     emit("changed");
   } catch (e) {
-    toast.error(e?.message ?? actionErrorFallback(a));
+    toast.error(errorReason(e, actionErrorFallback(a)));
   } finally {
     busy.value = false;
   }

package/dist/runtime/components/Integrations/RunDetailPanel.vue

@@ -3,8 +3,10 @@ import { computed, onUnmounted, ref, watch } from "vue";
 import { Download as DownloadIcon, RefreshCircle as RefreshIcon } from "#solar-icons";
 import { Badge, Button, Dialog, DialogContent, DialogHeader, DialogTitle } from "@revenexx/studio";
 import { runStatusClass, runStatusLabel } from "../../utils/statusStyle";
-import { IntegrationsApiError } from "../../utils/apiError";
+import { IntegrationsApiError, errorReason } from "../../utils/apiError";
 import { createPollBudget, SAFETY_POLL_MS } from "../../utils/pollBudget";
+import { formatDuration } from "../../utils/formatDuration";
+import { unwrapRun } from "../../utils/runEnvelope";
 const props = defineProps({
   run: { type: Object, required: true },
   view: { type: String, required: false, default: "details" }
@@ -59,14 +61,6 @@ function pickStr(obj, keys) {
   const v = pick(obj, keys);
   return v == null ? null : String(v);
 }
-function unwrapRun(res) {
-  if (!res || typeof res !== "object") return null;
-  const o = res;
-  if ("data" in o && o.data && typeof o.data === "object" && !("status" in o) && !("temporal_run_id" in o)) {
-    return o.data;
-  }
-  return o;
-}
 function isNonEmptyObject(v) {
   return !!v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 0;
 }
@@ -141,8 +135,7 @@ function statusOf(e) {
   return e instanceof IntegrationsApiError ? e.status : null;
 }
 function genericMsg(e, fallback) {
-  if (e instanceof IntegrationsApiError) return e.message || fallback;
-  return e?.message ?? fallback;
+  return errorReason(e, fallback);
 }
 function detailsErrMsg(e) {
   const s = statusOf(e);
@@ -170,12 +163,7 @@ function stepsErrMsg(e) {
   if (s === 503) return t("integration.runs.detail.error.details.unavailable");
   return genericMsg(e, t("integration.runs.detail.error.steps.generic"));
 }
-function fmtMs(ms) {
-  if (ms == null) return "\u2014";
-  if (ms < 1e3) return `${ms}ms`;
-  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)}s`;
-  return `${(ms / 6e4).toFixed(1)}m`;
-}
+const fmtMs = formatDuration;
 function activityName(a) {
   const at = a ? a.activity_type ?? a.activityType : void 0;
   if (typeof at === "string") return at;

package/dist/runtime/components/Integrations/RunResponseModal.d.vue.ts

@@ -1,18 +1,40 @@
+import type { RunOutput } from '../../utils/runOutputs.js';
 /**
- * Result surface for a manual run, sync and async alike. The parent opens it
- * in a loading state, awaits the trigger, then feeds through the outcome:
+ * Result surface for a manual run, sync and async alike.
  *
- *  - sync:  the run's response body (JSON) or a mapped error (timeout /
- *           failed run). A failed 422 ships the run object, so `runId` lets
- *           the operator jump straight into the run detail.
- *  - async: a started confirmation with the fresh run's number — the visible
- *           counterpart to the fire-and-forget POST.
+ * BOTH MODES END HERE, and that is the point of the component (PO-380). The
+ * parent opens it on the press, awaits the trigger, and then feeds through
+ * whatever it learns about the run — the body a sync request waited for, or the
+ * successive states of an async run the parent follows on the author's behalf.
+ * What differs between the two is only who does the waiting; the async branch
+ * used to stop at "run #99 started", which said that the press did something and
+ * nothing about what it did.
+ *
+ * WHAT IT LEADS WITH is the other half. A run's record carries its Temporal ids,
+ * its two re-run references and four timestamps, and the author pressed Run to
+ * see none of them: `outputs` is the returned value split per node and named the
+ * way the canvas names it, `result` is that value whole for a shape that cannot
+ * be split, and the record itself is a click away rather than printed here.
  */
+interface RunSummary {
+    id?: unknown;
+    status?: unknown;
+    started_at?: unknown;
+    completed_at?: unknown;
+}
 type __VLS_Props = {
     open: boolean;
+    /** The trigger request is still out. */
     loading?: boolean;
     mode?: 'sync' | 'async';
-    response?: unknown;
+    /** The run as the platform last reported it — the identity line above the result. */
+    run?: RunSummary | null;
+    /** What the run returned, per node. `null` where the value has no such shape. */
+    outputs?: RunOutput[] | null;
+    /** …and the value whole, for when it has not. */
+    result?: unknown;
+    /** The studio is still following a run that has not ended. */
+    following?: boolean;
     error?: string | null;
     /** The run behind this result (sync failure / async start) for deep-linking. */
     runId?: string | null;

package/dist/runtime/components/Integrations/RunResponseModal.vue

@@ -1,4 +1,5 @@
 <script setup>
+import { computed } from "vue";
 import { CheckCircle as CheckCircle2, RefreshCircle as Loader2 } from "#solar-icons";
 import {
   Button,
@@ -8,22 +9,50 @@ import {
   DialogHeader,
   DialogTitle
 } from "@revenexx/studio";
-defineProps({
+import { formatDuration } from "../../utils/formatDuration";
+import { runStatusClass, runStatusLabel } from "../../utils/statusStyle";
+import { isTerminalRun } from "../../utils/runEnvelope";
+const props = defineProps({
   open: { type: Boolean, required: true },
   loading: { type: Boolean, required: false },
   mode: { type: String, required: false },
-  response: { type: null, required: false },
+  run: { type: [Object, null], required: false },
+  outputs: { type: [Array, null], required: false },
+  result: { type: null, required: false },
+  following: { type: Boolean, required: false },
   error: { type: [String, null], required: false },
   runId: { type: [String, null], required: false }
 });
 const emit = defineEmits(["update:open", "view-run"]);
 const t = useIntegrationsT();
+const runNumber = computed(() => props.run?.id != null ? String(props.run.id) : props.runId);
+const status = computed(() => props.run?.status != null ? String(props.run.status) : "");
+const duration = computed(() => {
+  const from = props.run?.started_at;
+  const to = props.run?.completed_at;
+  if (typeof from !== "string" || typeof to !== "string") return null;
+  const ms = Date.parse(to) - Date.parse(from);
+  return Number.isFinite(ms) && ms >= 0 ? ms : null;
+});
+const ended = computed(() => {
+  if (props.following) return false;
+  if (props.mode !== "async") return true;
+  return isTerminalRun(props.run);
+});
+const returnedNothing = computed(() => props.result == null || typeof props.result === "object" && !Array.isArray(props.result) && !Object.keys(props.result).length);
+function pretty(value) {
+  return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
 </script>
 
 <template>
   <Dialog :open="open" @update:open="(v) => emit('update:open', v)">
     <!-- Wide result surface — but hard-capped: min-w-0 down the tree keeps the
-         JSON <pre> scrolling INSIDE instead of blowing the dialog open. -->
+         JSON <pre> scrolling INSIDE instead of blowing the dialog open. The same
+         had to be said about the height, and was not: the dialog grew as tall as
+         whatever came back, `overflow-hidden` clipped what stuck out, and nothing
+         scrolled — so a result of two node outputs ran off the top and the bottom
+         of the screen at once and took the buttons below it out of reach (PO-402). -->
     <DialogContent class="max-w-[94vw] overflow-hidden sm:max-w-4xl">
       <DialogHeader>
         <DialogTitle>{{ mode === "async" ? t("integration.runs.response.title.async") : t("integration.runs.response.title.sync") }}</DialogTitle>
@@ -32,7 +61,10 @@ const t = useIntegrationsT();
         </DialogDescription>
       </DialogHeader>
 
-      <div class="min-w-0 max-w-full text-sm">
+      <!-- The body is what scrolls, which is how the create-workflow, node-config
+           and SFTP-import dialogs solve the same thing. Capped below the viewport so
+           the dialog's own header stays put above it. -->
+      <div class="min-w-0 max-h-[70vh] max-w-full overflow-y-auto text-sm">
         <div v-if="loading" class="flex items-center gap-2 py-6 text-muted-foreground">
           <Loader2 :size="16" class="animate-spin" />
           {{ mode === "async" ? t("integration.runs.response.loading.async") : t("integration.runs.response.loading.sync") }}
@@ -49,36 +81,72 @@ const t = useIntegrationsT();
           </div>
         </template>
 
-        <template v-else-if="mode === 'async'">
-          <div class="flex items-center gap-2 rounded-md border border-emerald-500/20 bg-emerald-500/5 px-3 py-2 text-emerald-700">
+        <template v-else>
+          <!-- The confirmation an async press earns: the run exists and is named,
+               whatever the studio manages to read back about it afterwards. -->
+          <div
+            v-if="mode === 'async'"
+            class="flex items-center gap-2 rounded-md border border-emerald-500/20 bg-emerald-500/5 px-3 py-2 text-emerald-700"
+          >
             <CheckCircle2 :size="15" class="shrink-0" />
-            <span v-if="runId">{{ t("integration.runs.response.async.startedWithId", { id: runId }) }}</span>
+            <span v-if="runNumber">{{ t("integration.runs.response.async.startedWithId", { id: runNumber }) }}</span>
             <span v-else>{{ t("integration.runs.response.async.started") }}</span>
           </div>
-          <div class="mt-3 flex justify-end gap-2">
+
+          <!-- Where the run has got to: three facts, and the rest of its record
+               stays behind the button below. -->
+          <div v-if="runNumber || status" class="mt-3 flex flex-wrap items-center gap-x-2 gap-y-1 text-muted-foreground">
+            <span v-if="runNumber" class="font-mono">{{ t("integration.runs.response.runNumber", { id: runNumber }) }}</span>
+            <span
+              v-if="status"
+              class="rounded px-1.5 py-0.5 text-xs"
+              :class="runStatusClass(status)"
+            >{{ runStatusLabel(status) }}</span>
+            <span v-if="duration != null" class="tabular-nums text-xs">{{ formatDuration(duration) }}</span>
+          </div>
+
+          <div v-if="following" class="mt-3 flex items-center gap-2 py-3 text-muted-foreground">
+            <Loader2 :size="16" class="animate-spin" />
+            {{ t("integration.runs.response.following") }}
+          </div>
+
+          <!-- What it returned, one block per node that produced something. -->
+          <div v-else-if="outputs?.length" class="mt-3 space-y-3">
+            <div v-for="out in outputs" :key="out.nodeId" class="min-w-0">
+              <p class="mb-1 font-medium text-foreground">
+                {{ out.name }}
+              </p>
+              <pre
+                class="max-h-[45vh] w-full min-w-0 max-w-full overflow-auto rounded-md border border-black/[0.06] bg-slate-50 p-3 text-xs"
+              >{{ pretty(out.value) }}</pre>
+            </div>
+          </div>
+
+          <!-- Nothing at all where the run has not ended: the studio has stopped
+               looking, which is not the same as the run having finished, and the
+               confirmation and the status line above already say where it stands. -->
+          <template v-else-if="ended">
+            <p v-if="returnedNothing" class="mt-3 py-3 text-muted-foreground">
+              {{ t("integration.runs.response.nothingReturned") }}
+            </p>
+
+            <!-- A returned value this workflow's nodes cannot account for: shown
+                 whole rather than filed under a name it may not belong to. -->
+            <pre
+              v-else
+              class="mt-3 max-h-[60vh] w-full min-w-0 max-w-full overflow-auto rounded-md border border-black/[0.06] bg-slate-50 p-3 text-xs"
+            >{{ pretty(result) }}</pre>
+          </template>
+
+          <div class="mt-4 flex justify-end gap-2">
             <Button variant="outline" class="h-8 text-sm" @click="emit('update:open', false)">
               {{ t("integration.common.action.close") }}
             </Button>
-            <Button v-if="runId" class="h-8 text-sm" @click="emit('view-run', runId)">
+            <Button v-if="runNumber" class="h-8 text-sm" @click="emit('view-run', String(runNumber))">
               {{ t("integration.runs.response.action.viewRun") }}
             </Button>
           </div>
         </template>
-
-        <template v-else-if="response !== void 0 && response !== null">
-          <pre
-            class="max-h-[66vh] w-full min-w-0 max-w-full overflow-auto rounded-md border border-black/[0.06] bg-slate-50 p-3 text-xs"
-          >{{ JSON.stringify(response, null, 2) }}</pre>
-          <div v-if="runId" class="mt-3 flex justify-end">
-            <Button variant="outline" class="h-8 text-sm" @click="emit('view-run', runId)">
-              {{ t("integration.runs.response.action.viewRun") }}
-            </Button>
-          </div>
-        </template>
-
-        <p v-else class="py-6 text-muted-foreground">
-          {{ t("integration.runs.response.empty") }}
-        </p>
       </div>
     </DialogContent>
   </Dialog>

package/dist/runtime/components/Integrations/RunResponseModal.vue.d.ts

@@ -1,18 +1,40 @@
+import type { RunOutput } from '../../utils/runOutputs.js';
 /**
- * Result surface for a manual run, sync and async alike. The parent opens it
- * in a loading state, awaits the trigger, then feeds through the outcome:
+ * Result surface for a manual run, sync and async alike.
  *
- *  - sync:  the run's response body (JSON) or a mapped error (timeout /
- *           failed run). A failed 422 ships the run object, so `runId` lets
- *           the operator jump straight into the run detail.
- *  - async: a started confirmation with the fresh run's number — the visible
- *           counterpart to the fire-and-forget POST.
+ * BOTH MODES END HERE, and that is the point of the component (PO-380). The
+ * parent opens it on the press, awaits the trigger, and then feeds through
+ * whatever it learns about the run — the body a sync request waited for, or the
+ * successive states of an async run the parent follows on the author's behalf.
+ * What differs between the two is only who does the waiting; the async branch
+ * used to stop at "run #99 started", which said that the press did something and
+ * nothing about what it did.
+ *
+ * WHAT IT LEADS WITH is the other half. A run's record carries its Temporal ids,
+ * its two re-run references and four timestamps, and the author pressed Run to
+ * see none of them: `outputs` is the returned value split per node and named the
+ * way the canvas names it, `result` is that value whole for a shape that cannot
+ * be split, and the record itself is a click away rather than printed here.
  */
+interface RunSummary {
+    id?: unknown;
+    status?: unknown;
+    started_at?: unknown;
+    completed_at?: unknown;
+}
 type __VLS_Props = {
     open: boolean;
+    /** The trigger request is still out. */
     loading?: boolean;
     mode?: 'sync' | 'async';
-    response?: unknown;
+    /** The run as the platform last reported it — the identity line above the result. */
+    run?: RunSummary | null;
+    /** What the run returned, per node. `null` where the value has no such shape. */
+    outputs?: RunOutput[] | null;
+    /** …and the value whole, for when it has not. */
+    result?: unknown;
+    /** The studio is still following a run that has not ended. */
+    following?: boolean;
     error?: string | null;
     /** The run behind this result (sync failure / async start) for deep-linking. */
     runId?: string | null;

package/dist/runtime/components/Integrations/RunsTable.d.vue.ts

@@ -1,4 +1,5 @@
-import type { WorkflowRun } from '../../types/integrations.js';
+import type { RunStatus, TriggerType, WorkflowRun } from '../../types/integrations.js';
+import type { RunSort, RunSortDirection } from '../../utils/runFeedQuery.js';
 type __VLS_Props = {
     runs: WorkflowRun[];
     loading?: boolean;
@@ -7,14 +8,71 @@ type __VLS_Props = {
     pagination?: boolean;
     /** false inside a workflow — the context makes the column redundant. */
     showWorkflow?: boolean;
+    /**
+     * The owning list reads its page and its narrowing from the platform.
+     *
+     * The table then renders the rows it is handed and reports what the operator
+     * asked for, instead of narrowing and slicing an array. That is what lets the
+     * list reach past the newest hundred runs at all (PO-369).
+     */
+    serverMode?: boolean;
+    /** How many runs match the narrowing. The pager's "of 7"; server mode only. */
+    total?: number;
+    /**
+     * How many rows a page holds — the SAME number the page asks the platform for.
+     *
+     * The shared table works its footer's "showing 1–25 of 140" out from its own
+     * page size, so a table left on its default while the request asks for another
+     * number states a range that is simply wrong: it counted twenty where
+     * twenty-five had arrived.
+     */
+    perPage?: number;
+    /** The narrowing in force. Owned by the page, drawn here. */
+    status?: RunStatus[];
+    triggerType?: TriggerType | '';
+    /** The order the platform is reading the list in. Server mode only. */
+    sort?: RunSort;
+    direction?: RunSortDirection;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+type __VLS_PublicProps = __VLS_Props & {
+    /** 1-based, as the platform pages. The shared table counts from zero. */
+    'page'?: number;
+};
+declare const _default: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (text: string) => any;
     changed: () => any;
-}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    narrow: (patch: {
+        status?: RunStatus[];
+        triggerType?: TriggerType | "";
+    }) => any;
+    "page-size": (size: number) => any;
+    reorder: (order: {
+        sort: RunSort;
+        direction: RunSortDirection;
+    }) => any;
+    "update:page": (value: number) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onSearch?: ((text: string) => any) | undefined;
     onChanged?: (() => any) | undefined;
+    onNarrow?: ((patch: {
+        status?: RunStatus[];
+        triggerType?: TriggerType | "";
+    }) => any) | undefined;
+    "onPage-size"?: ((size: number) => any) | undefined;
+    onReorder?: ((order: {
+        sort: RunSort;
+        direction: RunSortDirection;
+    }) => any) | undefined;
+    "onUpdate:page"?: ((value: number) => any) | undefined;
 }>, {
+    sort: RunSort;
     loading: boolean;
+    total: number;
+    direction: RunSortDirection;
+    triggerType: TriggerType | "";
+    perPage: number;
     pagination: boolean;
     showWorkflow: boolean;
+    serverMode: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;