@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/solution-tests/solution-tests.js

@@ -0,0 +1,121 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useNavigate, useSearch } from "@tanstack/react-router";
+import { useState } from "react";
+import { toast } from "sonner";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { normalizeTab } from "./tabs.js";
+import { RunStatus } from "./types.js";
+import { useDeleteTest, useForceStopBatch, useRunTests, useSolutionTestBatchRuns, useSolutionTestRuns, useSolutionTests, useToggleTestActive } from "./hooks.js";
+import { SolutionTestsView } from "./solution-tests-view.js";
+import { ExpandedAgents } from "./expanded-agents.js";
+import { ExpandedRunTests } from "./expanded-run-tests.js";
+function getRunsForBatch(batchId, allRuns) {
+    return allRuns.filter((r)=>r.RunBatchId === batchId);
+}
+const SolutionTests = ()=>{
+    const { t } = useVertexTranslation();
+    const { tests, isLoading: testsLoading } = useSolutionTests();
+    const { batchRuns, isLoading: batchLoading } = useSolutionTestBatchRuns();
+    const { runs: allRuns } = useSolutionTestRuns();
+    const runTests = useRunTests();
+    const toggleActive = useToggleTestActive();
+    const deleteTest = useDeleteTest();
+    const forceStopBatch = useForceStopBatch();
+    const [deleteConfirmId, setDeleteConfirmId] = useState(null);
+    const [runConfirm, setRunConfirm] = useState(null);
+    const runMode = runTests.isPending ? runTests.variables?.mode ?? null : null;
+    const runningAll = "all" === runMode;
+    const runningSelected = "selected" === runMode;
+    const runningTestId = "test" === runMode ? runTests.variables?.testIds?.[0] ?? null : null;
+    const togglingTestId = toggleActive.isPending ? toggleActive.variables?.testId ?? null : null;
+    const forceStoppingBatchId = forceStopBatch.isPending ? forceStopBatch.variables ?? null : null;
+    const activeTab = useSearch({
+        strict: false,
+        select: (search)=>normalizeTab(search.tab)
+    });
+    const navigate = useNavigate();
+    const onTabChange = (tab)=>{
+        navigate({
+            to: ".",
+            search: (prev)=>({
+                    ...prev,
+                    tab
+                }),
+            replace: true
+        });
+    };
+    const hasActiveRuns = batchRuns.some((r)=>r.Status === RunStatus.Pending || r.Status === RunStatus.Running);
+    return /*#__PURE__*/ jsx(SolutionTestsView, {
+        tests: tests,
+        batchRuns: batchRuns,
+        loading: testsLoading || batchLoading,
+        activeTab: activeTab,
+        onTabChange: onTabChange,
+        hasActiveRuns: hasActiveRuns,
+        runningAll: runningAll,
+        runningSelected: runningSelected,
+        runningTestId: runningTestId,
+        togglingTestId: togglingTestId,
+        isDeleting: deleteTest.isPending,
+        forceStoppingBatchId: forceStoppingBatchId,
+        deleteConfirmId: deleteConfirmId,
+        setDeleteConfirmId: setDeleteConfirmId,
+        runConfirm: runConfirm,
+        setRunConfirm: setRunConfirm,
+        onConfirmRun: ()=>{
+            if (!runConfirm) return;
+            setRunConfirm(null);
+            if ("all" === runConfirm.mode) return void runTests.mutate({
+                mode: "all"
+            }, {
+                onSuccess: ()=>toast.success(t("all_tests_triggered")),
+                onError: (err)=>toast.error(err.message || t("failed_to_run_tests"))
+            });
+            if ("selected" === runConfirm.mode) return void runTests.mutate({
+                testIds: runConfirm.testIds,
+                mode: "selected"
+            }, {
+                onSuccess: ()=>toast.success(t("selected_tests_triggered")),
+                onError: (err)=>toast.error(err.message || t("failed_to_run_tests"))
+            });
+            runTests.mutate({
+                testIds: [
+                    runConfirm.testId
+                ],
+                mode: "test"
+            }, {
+                onSuccess: ()=>toast.success(t("test_triggered")),
+                onError: (err)=>toast.error(err.message || t("failed_to_run_test"))
+            });
+        },
+        onToggleActive: (testId, newValue)=>toggleActive.mutate({
+                testId,
+                isActive: newValue
+            }, {
+                onSuccess: ()=>toast.success(newValue ? t("test_enabled") : t("test_disabled")),
+                onError: (err)=>toast.error(err.message || t("failed_to_toggle_test"))
+            }),
+        onDeleteTest: (testId)=>{
+            deleteTest.mutate(testId, {
+                onSuccess: ()=>{
+                    toast.success(t("test_deleted"));
+                    setDeleteConfirmId(null);
+                },
+                onError: (err)=>toast.error(err.message || t("failed_to_delete_test"))
+            });
+        },
+        onForceStopBatch: (batchId)=>forceStopBatch.mutate(batchId, {
+                onSuccess: ()=>toast.success(t("force_stop_initiated")),
+                onError: (err)=>toast.error(err.message || t("failed_to_force_stop_batch"))
+            }),
+        renderExpandedTest: (test)=>/*#__PURE__*/ jsx(ExpandedAgents, {
+                test: test
+            }),
+        renderExpandedRun: (batch)=>/*#__PURE__*/ jsx(ExpandedRunTests, {
+                runs: getRunsForBatch(batch.Id, allRuns),
+                tests: tests
+            })
+    });
+};
+export { SolutionTests };

package/dist/registry/solution-tests/status-maps.d.ts

@@ -0,0 +1,5 @@
+export type BadgeStatus = "success" | "warning" | "error" | "info";
+export declare const testStatusBadgeMap: Record<number, BadgeStatus>;
+export declare const runStatusBadgeMap: Record<number, BadgeStatus>;
+export declare const runResultStatusBadgeMap: Record<number, BadgeStatus>;
+export declare const resultBadgeClassMap: Record<number, string>;

package/dist/registry/solution-tests/status-maps.js

@@ -0,0 +1,26 @@
+import { RunResultStatus, RunStatus, SolutionTestStatus } from "./types.js";
+const testStatusBadgeMap = {
+    [SolutionTestStatus.Ready]: "success",
+    [SolutionTestStatus.Pending]: "warning",
+    [SolutionTestStatus.Error]: "error"
+};
+const runStatusBadgeMap = {
+    [RunStatus.Passed]: "success",
+    [RunStatus.Running]: "warning",
+    [RunStatus.Failed]: "error",
+    [RunStatus.Error]: "error",
+    [RunStatus.Pending]: "info",
+    [RunStatus.Aborted]: "warning"
+};
+const runResultStatusBadgeMap = {
+    [RunResultStatus.Passed]: "success",
+    [RunResultStatus.Failed]: "error",
+    [RunResultStatus.Error]: "warning",
+    [RunResultStatus.NoBaseline]: "info",
+    [RunResultStatus.Pending]: "info",
+    [RunResultStatus.Aborted]: "warning"
+};
+const resultBadgeClassMap = {
+    [RunResultStatus.Missing]: "border-transparent bg-muted text-muted-foreground"
+};
+export { resultBadgeClassMap, runResultStatusBadgeMap, runStatusBadgeMap, testStatusBadgeMap };

package/dist/registry/solution-tests/tabs.d.ts

@@ -0,0 +1,4 @@
+export type SolutionTestsTab = "cases" | "runs";
+export declare const DEFAULT_TAB: SolutionTestsTab;
+/** Coerce a raw value to a known tab, falling back to the default. */
+export declare function normalizeTab(value: unknown): SolutionTestsTab;

package/dist/registry/solution-tests/tabs.js

@@ -0,0 +1,5 @@
+const DEFAULT_TAB = "cases";
+function normalizeTab(value) {
+    return "runs" === value ? "runs" : DEFAULT_TAB;
+}
+export { DEFAULT_TAB, normalizeTab };

package/dist/registry/solution-tests/types.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Solution Test view models — the data contracts this UI renders.
+ *
+ * These map to the UiPathST* family of Solution Test entities and are
+ * intentionally domain-neutral. The "subject" of a test (a loan, an invoice,
+ * a claim, …) is represented by the optional `SubjectId` / `Subject` fields;
+ * consumers render subject-specific columns through `SolutionTestsConfig`.
+ */
+export declare const SolutionTestStatus: {
+    readonly Pending: 0;
+    readonly Ready: 1;
+    readonly Error: 2;
+};
+export type SolutionTestStatusValue = (typeof SolutionTestStatus)[keyof typeof SolutionTestStatus];
+export declare const RunStatus: {
+    readonly Pending: 0;
+    readonly Running: 1;
+    readonly Passed: 2;
+    readonly Failed: 3;
+    readonly Error: 4;
+    readonly Aborted: 5;
+};
+export type RunStatusValue = (typeof RunStatus)[keyof typeof RunStatus];
+export declare const RunResultStatus: {
+    readonly Pending: 0;
+    readonly Passed: 1;
+    readonly Failed: 2;
+    readonly Error: 3;
+    readonly NoBaseline: 4;
+    readonly Missing: 5;
+    readonly Aborted: 6;
+};
+export type RunResultStatusValue = (typeof RunResultStatus)[keyof typeof RunResultStatus];
+export declare const JobRole: {
+    readonly EntryPoint: 0;
+    readonly Baseline: 1;
+};
+export type JobRoleValue = (typeof JobRole)[keyof typeof JobRole];
+export interface SolutionTest {
+    Id: string;
+    TestName?: string;
+    VerticalSolutionVersion?: string;
+    /** Vertical configuration version the baseline was captured under. */
+    ConfigVersion?: string;
+    Status: number;
+    IsActive?: boolean;
+    UserMessages?: string;
+    SubjectId?: string;
+    /** Arbitrary subject fields, read by consumer-supplied subject columns. */
+    Subject?: Record<string, unknown>;
+}
+export interface SolutionTestJob {
+    Id: string;
+    SolutionTestId: string;
+    JobRole: number;
+    ProcessName: string;
+    ProcessVersion?: string;
+    /** Stable agent id (uipath.json#id). */
+    AgentId?: string;
+    SourceRunResultId?: string;
+}
+export interface SolutionTestRun {
+    Id: string;
+    SolutionTestId: string;
+    RunBatchId: string;
+    Status: number;
+    VerticalSolutionVersion?: string;
+    /** Vertical configuration version this run executed against. */
+    ConfigVersion?: string;
+    /** Vertical configuration version from the test baseline. */
+    BaselineConfigVersion?: string;
+    TestRunScore?: number;
+    JobsPassed?: number;
+    JobsTotal?: number;
+    UserMessages?: string;
+    StartedAt?: string;
+    CompletedAt?: string;
+    CreateTime?: string;
+}
+export interface SolutionTestBatchRun {
+    Id: string;
+    Status: number;
+    OverallScore?: number;
+    TestsPassed?: number;
+    TestsTotal?: number;
+    VerticalSolutionVersion?: string;
+    UserMessages?: string;
+    StartedAt?: string;
+    CompletedAt?: string;
+    CreateTime?: string;
+}
+export interface SolutionTestRunResult {
+    Id: string;
+    SolutionTestRunId: string;
+    /** Id of the owning job; join against `UiPathSTJobs` to read its `JobRole`. */
+    SolutionTestJobId?: string;
+    ProcessName: string;
+    ProcessVersion?: string;
+    BaselineProcessVersion?: string;
+    /** Stable agent id (uipath.json#id). */
+    AgentId?: string;
+    Status: number;
+    Score?: number;
+    UserMessages?: string;
+    ErrorMessage?: string;
+}
+export type { UserMessageItem } from "./user-messages";
+/** Per-result attachment slots surfaced in the run-details dialog. */
+export type ResultAttachmentField = "ExpectedOutput" | "ExpectedInput" | "ActualOutput" | "ActualInput" | "EvaluatorResults";

package/dist/registry/solution-tests/types.js

@@ -0,0 +1,27 @@
+const SolutionTestStatus = {
+    Pending: 0,
+    Ready: 1,
+    Error: 2
+};
+const RunStatus = {
+    Pending: 0,
+    Running: 1,
+    Passed: 2,
+    Failed: 3,
+    Error: 4,
+    Aborted: 5
+};
+const RunResultStatus = {
+    Pending: 0,
+    Passed: 1,
+    Failed: 2,
+    Error: 3,
+    NoBaseline: 4,
+    Missing: 5,
+    Aborted: 6
+};
+const JobRole = {
+    EntryPoint: 0,
+    Baseline: 1
+};
+export { JobRole, RunResultStatus, RunStatus, SolutionTestStatus };

package/dist/registry/solution-tests/use-baseline-jobs.d.ts

@@ -0,0 +1,12 @@
+import type { AttachmentFetcher, MutationHook } from "./mutations";
+import type { SolutionTestJob } from "./types";
+export interface UseBaselineJobsResult {
+    jobs: SolutionTestJob[];
+    isLoading: boolean;
+}
+/** Live baseline jobs for a test. */
+export declare function useBaselineJobs(testId: string): UseBaselineJobsResult;
+/** Remove a job from the test's expected (baseline) results. */
+export declare function useRemoveJobBaseline(): MutationHook<string>;
+/** Expected-output attachment for a baseline job (Agents expansion). */
+export declare function useJobExpectedOutput(): AttachmentFetcher<[jobId: string]>;

package/dist/registry/solution-tests/use-baseline-jobs.js

@@ -0,0 +1,48 @@
+"use client";
+import { useLiveQuery } from "@tanstack/react-db";
+import { useMutation } from "@tanstack/react-query";
+import { useSolution } from "@uipath/vs-core";
+import { fetchAttachment } from "./attachments.js";
+import { ENTITY } from "./constants.js";
+import { useSolutionTestsActions, useSolutionTestsConfig, useSolutionTestsContext } from "./context.js";
+import { JobRole } from "./types.js";
+import { useSolutionTestCollection } from "./use-solution-test-collection.js";
+function useBaselineJobs(testId) {
+    const collection = useSolutionTestCollection(ENTITY.jobs);
+    const { data, isLoading } = useLiveQuery((q)=>q.from({
+            jobs: collection
+        }), [
+        collection
+    ]);
+    const jobs = (data ?? []).filter((job)=>job.SolutionTestId === testId && job.JobRole === JobRole.Baseline);
+    return {
+        jobs,
+        isLoading
+    };
+}
+function useRemoveJobBaseline() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    const jobsCollection = useSolutionTestCollection(ENTITY.jobs);
+    return useMutation({
+        mutationFn: async (baselineId)=>{
+            await actions.removeJobBaseline(baselineId);
+            await jobsCollection.utils.refetch();
+        },
+        onMutate: (baselineId)=>track?.("VS.SolutionTest.BaselineRemoved", {
+                baselineId
+            })
+    });
+}
+function useJobExpectedOutput() {
+    const solution = useSolution();
+    const { attachmentScope } = useSolutionTestsContext();
+    return {
+        fetch: (jobId)=>{
+            const entityId = solution?.api.entityIds?.[ENTITY.jobs];
+            if (!entityId) return Promise.resolve(null);
+            return fetchAttachment(solution, entityId, jobId, "Output", attachmentScope?.());
+        }
+    };
+}
+export { useBaselineJobs, useJobExpectedOutput, useRemoveJobBaseline };

package/dist/registry/solution-tests/use-force-stop.d.ts

@@ -0,0 +1,5 @@
+import type { MutationHook } from "./mutations";
+/** Force-stop a whole batch run. */
+export declare function useForceStopBatch(): MutationHook<string>;
+/** Force-stop a single run. */
+export declare function useForceStopRun(): MutationHook<string>;

package/dist/registry/solution-tests/use-force-stop.js

@@ -0,0 +1,24 @@
+"use client";
+import { useMutation } from "@tanstack/react-query";
+import { useSolutionTestsActions, useSolutionTestsConfig } from "./context.js";
+function useForceStopBatch() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    return useMutation({
+        mutationFn: (batchId)=>actions.forceStopBatch(batchId),
+        onMutate: (batchId)=>track?.("VS.SolutionTest.BatchForceStopped", {
+                batchId
+            })
+    });
+}
+function useForceStopRun() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    return useMutation({
+        mutationFn: (runId)=>actions.forceStopRun(runId),
+        onMutate: (runId)=>track?.("VS.SolutionTest.RunForceStopped", {
+                runId
+            })
+    });
+}
+export { useForceStopBatch, useForceStopRun };

package/dist/registry/solution-tests/use-run-results.d.ts

@@ -0,0 +1,17 @@
+import type { AttachmentFetcher, MutationHook } from "./mutations";
+import type { ResultAttachmentField, SolutionTestRunResult } from "./types";
+export interface UseRunResultsResult {
+    results: SolutionTestRunResult[];
+    isLoading: boolean;
+}
+/** Live run results for a run, excluding entry-point jobs (role != Baseline). */
+export declare function useRunResults(runId: string): UseRunResultsResult;
+/** Adopt a run result's job as the test baseline. */
+export declare function useAdoptJob(): MutationHook<string>;
+/** Update the test baseline from a run result. */
+export declare function useUpdateBaseline(): MutationHook<string>;
+/** One attachment slot for a run result (run-details expansion). */
+export declare function useResultAttachment(): AttachmentFetcher<[
+    resultId: string,
+    field: ResultAttachmentField
+]>;

package/dist/registry/solution-tests/use-run-results.js

@@ -0,0 +1,75 @@
+"use client";
+import { useLiveQuery } from "@tanstack/react-db";
+import { useMutation } from "@tanstack/react-query";
+import { useSolution } from "@uipath/vs-core";
+import { fetchAttachment } from "./attachments.js";
+import { ENTITY } from "./constants.js";
+import { useSolutionTestsActions, useSolutionTestsConfig, useSolutionTestsContext } from "./context.js";
+import { JobRole } from "./types.js";
+import { useSolutionTestCollection } from "./use-solution-test-collection.js";
+function isBaselineJobResult(result, jobsById) {
+    const jobId = result.SolutionTestJobId;
+    if (null == jobId) return true;
+    const job = jobsById.get(jobId);
+    if (!job) return true;
+    return job.JobRole === JobRole.Baseline;
+}
+function useRunResults(runId) {
+    const resultsCollection = useSolutionTestCollection(ENTITY.runResults);
+    const jobsCollection = useSolutionTestCollection(ENTITY.jobs);
+    const { data, isReady: resultsReady } = useLiveQuery((q)=>q.from({
+            results: resultsCollection
+        }), [
+        resultsCollection
+    ]);
+    const { data: jobsData, isReady: jobsReady } = useLiveQuery((q)=>q.from({
+            jobs: jobsCollection
+        }), [
+        jobsCollection
+    ]);
+    if (!resultsReady || !jobsReady) return {
+        results: [],
+        isLoading: true
+    };
+    const jobsById = new Map((jobsData ?? []).map((job)=>[
+            job.Id,
+            job
+        ]));
+    const results = (data ?? []).filter((result)=>result.SolutionTestRunId === runId).filter((result)=>isBaselineJobResult(result, jobsById));
+    return {
+        results,
+        isLoading: false
+    };
+}
+function useAdoptJob() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    return useMutation({
+        mutationFn: (resultId)=>actions.adoptJob(resultId),
+        onMutate: (resultId)=>track?.("VS.SolutionTest.JobAdopted", {
+                resultId
+            })
+    });
+}
+function useUpdateBaseline() {
+    const actions = useSolutionTestsActions();
+    const { track } = useSolutionTestsConfig();
+    return useMutation({
+        mutationFn: (resultId)=>actions.updateBaseline(resultId),
+        onMutate: (resultId)=>track?.("VS.SolutionTest.BaselineUpdated", {
+                resultId
+            })
+    });
+}
+function useResultAttachment() {
+    const solution = useSolution();
+    const { attachmentScope } = useSolutionTestsContext();
+    return {
+        fetch: (resultId, field)=>{
+            const entityId = solution?.api.entityIds?.[ENTITY.runResults];
+            if (!entityId) return Promise.resolve(null);
+            return fetchAttachment(solution, entityId, resultId, field, attachmentScope?.());
+        }
+    };
+}
+export { useAdoptJob, useResultAttachment, useRunResults, useUpdateBaseline };

package/dist/registry/solution-tests/use-solution-test-batch-runs.d.ts

@@ -0,0 +1,7 @@
+import type { SolutionTestBatchRun } from "./types";
+export interface UseSolutionTestBatchRunsResult {
+    batchRuns: SolutionTestBatchRun[];
+    isLoading: boolean;
+}
+/** Live list of batch runs. */
+export declare function useSolutionTestBatchRuns(): UseSolutionTestBatchRunsResult;

package/dist/registry/solution-tests/use-solution-test-batch-runs.js

@@ -0,0 +1,17 @@
+"use client";
+import { useLiveQuery } from "@tanstack/react-db";
+import { ENTITY } from "./constants.js";
+import { useSolutionTestCollection } from "./use-solution-test-collection.js";
+function useSolutionTestBatchRuns() {
+    const collection = useSolutionTestCollection(ENTITY.batchRuns);
+    const { data, isLoading } = useLiveQuery((q)=>q.from({
+            batchRuns: collection
+        }), [
+        collection
+    ]);
+    return {
+        batchRuns: data ?? [],
+        isLoading
+    };
+}
+export { useSolutionTestBatchRuns };

package/dist/registry/solution-tests/use-solution-test-collection.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Resolve a typed Solution Tests collection by entity name. The entity name
+ * determines the row type, so callers cannot mismatch the two. Throws when used
+ * outside a SolutionProvider or when the named collection is not registered.
+ */
+import type { Collection } from "@tanstack/react-db";
+import { ENTITY } from "./constants";
+import type { SolutionTest, SolutionTestBatchRun, SolutionTestJob, SolutionTestRun, SolutionTestRunResult } from "./types";
+/** Row type stored in each Solution Tests collection, keyed by its entity name. */
+type SolutionTestRow = {
+    [ENTITY.tests]: SolutionTest;
+    [ENTITY.batchRuns]: SolutionTestBatchRun;
+    [ENTITY.runs]: SolutionTestRun;
+    [ENTITY.jobs]: SolutionTestJob;
+    [ENTITY.runResults]: SolutionTestRunResult;
+};
+export declare function useSolutionTestCollection<K extends keyof SolutionTestRow>(entity: K): Collection<SolutionTestRow[K]>;
+export {};

package/dist/registry/solution-tests/use-solution-test-collection.js

@@ -0,0 +1,11 @@
+"use client";
+import { useSolution } from "@uipath/vs-core";
+function useSolutionTestCollection(entity) {
+    const solution = useSolution();
+    if (!solution) throw new Error("useSolutionTestCollection must be used within a SolutionProvider.");
+    const selected = solution.api.collections.solutionTests[entity];
+    const collection = selected;
+    if (!collection) throw new Error(`Solution Tests collection "${entity}" is unavailable.`);
+    return collection;
+}
+export { useSolutionTestCollection };

package/dist/registry/solution-tests/use-solution-test-runs.d.ts

@@ -0,0 +1,7 @@
+import type { SolutionTestRun } from "./types";
+export interface UseSolutionTestRunsResult {
+    runs: SolutionTestRun[];
+    isLoading: boolean;
+}
+/** Live list of all runs (the view filters by batch in memory). */
+export declare function useSolutionTestRuns(): UseSolutionTestRunsResult;

package/dist/registry/solution-tests/use-solution-test-runs.js

@@ -0,0 +1,17 @@
+"use client";
+import { useLiveQuery } from "@tanstack/react-db";
+import { ENTITY } from "./constants.js";
+import { useSolutionTestCollection } from "./use-solution-test-collection.js";
+function useSolutionTestRuns() {
+    const collection = useSolutionTestCollection(ENTITY.runs);
+    const { data, isLoading } = useLiveQuery((q)=>q.from({
+            runs: collection
+        }), [
+        collection
+    ]);
+    return {
+        runs: data ?? [],
+        isLoading
+    };
+}
+export { useSolutionTestRuns };

package/dist/registry/solution-tests/use-solution-tests.d.ts

@@ -0,0 +1,30 @@
+import type { MutationHook } from "./mutations";
+import type { SolutionTest } from "./types";
+export interface UseSolutionTestsResult {
+    tests: SolutionTest[];
+    isLoading: boolean;
+}
+/** Live list of solution tests. */
+export declare function useSolutionTests(): UseSolutionTestsResult;
+/** Which run a `useRunTests` mutation represents; lets callers tell a single
+ * bulk-selected run apart from a single-row run (both carry one `testId`). */
+export type RunTestsMode = "all" | "test" | "selected";
+/** Run the given tests (all active tests when `testIds` is omitted). */
+export declare function useRunTests(): MutationHook<{
+    testIds?: string[];
+    mode: RunTestsMode;
+}>;
+/** Create a solution test from a subject id (e.g. a loan). */
+export declare function useCreateTest(): MutationHook<string>;
+/**
+ * Toggle a test's active flag. Unlike the other writes this isn't an API
+ * trigger — it's a direct field update on the `UiPathSTTests` collection, so it
+ * goes through the collection's optimistic `.update()` (synced to the backend
+ * by vs-core) rather than the injected `actions`.
+ */
+export declare function useToggleTestActive(): MutationHook<{
+    testId: string;
+    isActive: boolean;
+}>;
+/** Delete a test. */
+export declare function useDeleteTest(): MutationHook<string>;