@everysk/apps-sdk 0.1.0-beta.0

package/dist/hooks/workflow/useFetchWorkflow.js

@@ -0,0 +1,70 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.js";
+import { getWorkflow } from "../../api/workflow.js";
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+//#region src/hooks/workflow/useFetchWorkflow.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkflow
+*
+* Data-fetching hook built on TanStack Query to retrieve a single workflow by ID.
+*
+* It also:
+* - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+* - triggers an error alert via `useAppAlert` whenever `query.error` is present
+*
+* @param id - Workflow identifier (required).
+* @param workspace - Workspace the workflow belongs to (required).
+* @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+*
+* @returns TanStack Query result extended with `queryKey`.
+*
+* Tip:
+* - The returned `queryKey` can be reused by mutation hooks for cache invalidation:
+*   ```ts
+*   const fetch = useFetchWorkflow({ id: "wf-123", workspace: "main" });
+*   useWorkflowMutations({ queryKey: fetch.queryKey });
+*   ```
+*
+* Example:
+* ```ts
+* const { data, isLoading } = useFetchWorkflow({ id: "wf-123", workspace: "main" });
+* // data -> Workflow
+* ```
+*/
+var useFetchWorkflow = ({ id, workspace, queryOptions = defaultQueryOptions }) => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	const queryKey = [
+		"workflow",
+		id,
+		workspace
+	];
+	const query = useQuery({
+		queryKey,
+		queryFn: async () => {
+			return await getWorkflow(api, id, workspace);
+		},
+		...queryOptions ?? {}
+	});
+	useEffect(() => {
+		if (!query.error) return;
+		showAlert({
+			severity: "error",
+			message: query.error.message
+		});
+	}, [query.error, showAlert]);
+	return {
+		...query,
+		queryKey
+	};
+};
+//#endregion
+export { useFetchWorkflow };
+
+//# sourceMappingURL=useFetchWorkflow.js.map

package/dist/hooks/workflow/useFetchWorkflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflow.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflow.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { getWorkflow } from \"@/api/workflow\";\nimport type { Workflow } from \"@/types/workflow\";\nimport type { EntityQueryOptions, FetchEntityParams } from \"@/types/entityQuery\";\n\nexport type FetchWorkflowProps<TData = Workflow, TSelected = TData> = FetchEntityParams<TData, TSelected>;\n\nconst defaultQueryOptions: EntityQueryOptions<Workflow> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0\n}\n\n/**\n * useFetchWorkflow\n *\n * Data-fetching hook built on TanStack Query to retrieve a single workflow by ID.\n *\n * It also:\n * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * @param id - Workflow identifier (required).\n * @param workspace - Workspace the workflow belongs to (required).\n * @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *\n * @returns TanStack Query result extended with `queryKey`.\n *\n * Tip:\n * - The returned `queryKey` can be reused by mutation hooks for cache invalidation:\n *   ```ts\n *   const fetch = useFetchWorkflow({ id: \"wf-123\", workspace: \"main\" });\n *   useWorkflowMutations({ queryKey: fetch.queryKey });\n *   ```\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchWorkflow({ id: \"wf-123\", workspace: \"main\" });\n * // data -> Workflow\n * ```\n */\nexport const useFetchWorkflow = ({ id, workspace, queryOptions = defaultQueryOptions }: FetchWorkflowProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"workflow\", id, workspace];\n\n    const query = useQuery<Workflow>({\n        queryKey,\n        queryFn: async () => {\n            const workflow = await getWorkflow(api, id, workspace);\n            return workflow;\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;AAYA,IAAM,sBAAoD;CACtD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,oBAAoB,EAAE,IAAI,WAAW,eAAe,0BAA8C;CAE3G,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EAAC;EAAY;EAAI;CAAS;CAE3C,MAAM,QAAQ,SAAmB;EAC7B;EACA,SAAS,YAAY;GAEjB,OAAO,MADgB,YAAY,KAAK,IAAI,SAAS;EAEzD;EACA,GAAG,gBAAgB,CAAC;CACxB,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GACN,UAAU;GACV,SAAS,MAAM,MAAM;EACzB,CAAC;CACL,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;EACH,GAAG;EACH;CACJ;AACJ"}

package/dist/hooks/workflow/useFetchWorkflowExecution.d.ts

@@ -0,0 +1,198 @@
+import type { WorkflowExecution } from "../../types/workflow.d.ts";
+import type { EntityQueryOptions } from "../../types/entityQuery.d.ts";
+export type FetchWorkflowExecutionProps<TData = WorkflowExecution, TSelected = TData> = {
+    workflowId: string;
+    workflowExecutionId: string;
+    workspace: string;
+    queryOptions?: EntityQueryOptions<TData, TSelected>;
+};
+/**
+ * useFetchWorkflowExecution
+ *
+ * Data-fetching hook built on TanStack Query to retrieve a single workflow execution.
+ *
+ * It also:
+ * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+ * - triggers an error alert via `useAppAlert` whenever `query.error` is present
+ *
+ * @param workflowId - Workflow identifier the execution belongs to (required).
+ * @param workflowExecutionId - Workflow execution identifier (required).
+ * @param workspace - Workspace the workflow belongs to (required).
+ * @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * @returns TanStack Query result extended with `queryKey`.
+ *
+ * Example:
+ * ```ts
+ * const { data, isLoading } = useFetchWorkflowExecution({
+ *   workflowId: "wf-123",
+ *   workflowExecutionId: "exec-456",
+ *   workspace: "main",
+ * });
+ * // data -> WorkflowExecution
+ * ```
+ */
+export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecutionId, workspace, queryOptions }: FetchWorkflowExecutionProps) => {
+    queryKey: string[];
+    data: WorkflowExecution;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: WorkflowExecution;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+} | {
+    queryKey: string[];
+    data: WorkflowExecution;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+};
+//# sourceMappingURL=useFetchWorkflowExecution.d.ts.map

package/dist/hooks/workflow/useFetchWorkflowExecution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflowExecution.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflowExecution.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,MAAM,2BAA2B,CAAC,KAAK,GAAG,iBAAiB,EAAE,SAAS,GAAG,KAAK,IAAI;IACpF,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,kBAAkB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;CACvD,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,yBAAyB,GAAI,8DAAoF,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxJ,CAAC"}

package/dist/hooks/workflow/useFetchWorkflowExecution.js

@@ -0,0 +1,69 @@
+import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
+import { useAxios } from "../useAxios.js";
+import { getWorkflowExecution } from "../../api/workflow.js";
+import { useEffect } from "react";
+import { useQuery } from "@tanstack/react-query";
+//#region src/hooks/workflow/useFetchWorkflowExecution.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkflowExecution
+*
+* Data-fetching hook built on TanStack Query to retrieve a single workflow execution.
+*
+* It also:
+* - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation
+* - triggers an error alert via `useAppAlert` whenever `query.error` is present
+*
+* @param workflowId - Workflow identifier the execution belongs to (required).
+* @param workflowExecutionId - Workflow execution identifier (required).
+* @param workspace - Workspace the workflow belongs to (required).
+* @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).
+*
+* @returns TanStack Query result extended with `queryKey`.
+*
+* Example:
+* ```ts
+* const { data, isLoading } = useFetchWorkflowExecution({
+*   workflowId: "wf-123",
+*   workflowExecutionId: "exec-456",
+*   workspace: "main",
+* });
+* // data -> WorkflowExecution
+* ```
+*/
+var useFetchWorkflowExecution = ({ workflowId, workflowExecutionId, workspace, queryOptions = defaultQueryOptions }) => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	const queryKey = [
+		"workflow_execution",
+		workflowId,
+		workflowExecutionId,
+		workspace
+	];
+	const query = useQuery({
+		queryKey,
+		queryFn: async () => {
+			return await getWorkflowExecution(api, workflowId, workflowExecutionId, workspace);
+		},
+		...queryOptions ?? {}
+	});
+	useEffect(() => {
+		if (!query.error) return;
+		showAlert({
+			severity: "error",
+			message: query.error.message
+		});
+	}, [query.error, showAlert]);
+	return {
+		...query,
+		queryKey
+	};
+};
+//#endregion
+export { useFetchWorkflowExecution };
+
+//# sourceMappingURL=useFetchWorkflowExecution.js.map

package/dist/hooks/workflow/useFetchWorkflowExecution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflowExecution.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflowExecution.ts"],"sourcesContent":["import { useEffect } from \"react\";\n\nimport { useQuery } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { getWorkflowExecution } from \"@/api/workflow\";\nimport type { WorkflowExecution } from \"@/types/workflow\";\nimport type { EntityQueryOptions } from \"@/types/entityQuery\";\n\nexport type FetchWorkflowExecutionProps<TData = WorkflowExecution, TSelected = TData> = {\n    workflowId: string;\n    workflowExecutionId: string;\n    workspace: string;\n    queryOptions?: EntityQueryOptions<TData, TSelected>;\n};\n\nconst defaultQueryOptions: EntityQueryOptions<WorkflowExecution> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkflowExecution\n *\n * Data-fetching hook built on TanStack Query to retrieve a single workflow execution.\n *\n * It also:\n * - builds a stable React Query `queryKey` that can be reused by mutation hooks for cache invalidation\n * - triggers an error alert via `useAppAlert` whenever `query.error` is present\n *\n * @param workflowId - Workflow identifier the execution belongs to (required).\n * @param workflowExecutionId - Workflow execution identifier (required).\n * @param workspace - Workspace the workflow belongs to (required).\n * @param queryOptions - TanStack Query options passed through to `useQuery` (e.g., enabled, staleTime, gcTime, etc.).\n *\n * @returns TanStack Query result extended with `queryKey`.\n *\n * Example:\n * ```ts\n * const { data, isLoading } = useFetchWorkflowExecution({\n *   workflowId: \"wf-123\",\n *   workflowExecutionId: \"exec-456\",\n *   workspace: \"main\",\n * });\n * // data -> WorkflowExecution\n * ```\n */\nexport const useFetchWorkflowExecution = ({ workflowId, workflowExecutionId, workspace, queryOptions = defaultQueryOptions }: FetchWorkflowExecutionProps) => {\n\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    const queryKey = [\"workflow_execution\", workflowId, workflowExecutionId, workspace];\n\n    const query = useQuery<WorkflowExecution>({\n        queryKey,\n        queryFn: async () => {\n            const execution = await getWorkflowExecution(api, workflowId, workflowExecutionId, workspace);\n            return execution;\n        },\n        ...queryOptions ?? {}\n    });\n\n    useEffect(() => {\n        if (!query.error) return;\n\n        showAlert({\n            severity: \"error\",\n            message: query.error.message,\n        });\n    }, [query.error, showAlert]);\n\n    return {\n        ...query,\n        queryKey,\n    };\n};\n"],"mappings":";;;;;;AAiBA,IAAM,sBAA6D;CAC/D,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAa,6BAA6B,EAAE,YAAY,qBAAqB,WAAW,eAAe,0BAAuD;CAE1J,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAElC,MAAM,WAAW;EAAC;EAAsB;EAAY;EAAqB;CAAS;CAElF,MAAM,QAAQ,SAA4B;EACtC;EACA,SAAS,YAAY;GAEjB,OAAO,MADiB,qBAAqB,KAAK,YAAY,qBAAqB,SAAS;EAEhG;EACA,GAAG,gBAAgB,CAAC;CACxB,CAAC;CAED,gBAAgB;EACZ,IAAI,CAAC,MAAM,OAAO;EAElB,UAAU;GACN,UAAU;GACV,SAAS,MAAM,MAAM;EACzB,CAAC;CACL,GAAG,CAAC,MAAM,OAAO,SAAS,CAAC;CAE3B,OAAO;EACH,GAAG;EACH;CACJ;AACJ"}

package/dist/hooks/workflow/useFetchWorkflowExecutions.d.ts

@@ -0,0 +1,49 @@
+import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
+import type { FetchEntitiesParams } from "../../types/entityQuery.d.ts";
+import type { WorkflowExecution, WorkflowExecutionListResponse } from "../../types/workflow.d.ts";
+type PageToken = string | null;
+type InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkflowExecutionListResponse, Error, TData, QueryKey, PageToken>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+export type FetchInfiniteWorkflowExecutionProps = FetchEntitiesParams<WorkflowExecution[], InfiniteOptions<WorkflowExecution[]>> & {
+    workflowId: string;
+    pageSize?: number;
+};
+/**
+ * useFetchWorkflowExecutions
+ *
+ * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+ * workflow executions for a given workflow with cursor-based pagination.
+ *
+ * Automatically flattens all pages into a single `WorkflowExecution[]` via `select`.
+ *
+ * Note: `query.data` returns a flat `WorkflowExecution[]` with all fetched items merged across pages.
+ *
+ * @param workflowId - Workflow identifier whose executions to fetch (required).
+ * @param filters - Filters applied to every page request. Must include a `workspace` filter.
+ * @param order - Sorting applied to every page request.
+ * @param projection - Single field to project: `"field"` returns only that field (others come
+ *   back null), `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
+ * @param pageSize - Number of executions to fetch per page. Defaults to `10`.
+ * @param queryOptions - TanStack Query options passed through to `useInfiniteQuery`.
+ *
+ * @returns
+ *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * @example
+ * ```ts
+ * const { query } = useFetchWorkflowExecutions({
+ *   workflowId: "wf-123",
+ *   filters: [{ field: "workspace", value: "main" }],
+ *   pageSize: 20,
+ * });
+ *
+ * // Flat list of all fetched executions
+ * const executions = query.data ?? [];
+ * ```
+ */
+export declare function useFetchWorkflowExecutions({ workflowId, filters, order, projection, pageSize, queryOptions }: FetchInfiniteWorkflowExecutionProps): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<WorkflowExecution[], Error>;
+    queryKey: unknown[];
+};
+export {};
+//# sourceMappingURL=useFetchWorkflowExecutions.d.ts.map

package/dist/hooks/workflow/useFetchWorkflowExecutions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflowExecutions.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflowExecutions.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AAEzF,KAAK,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/B,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC,uBAAuB,CAAC,6BAA6B,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CAAC,CAAC;AAEhM,MAAM,MAAM,mCAAmC,GAAG,mBAAmB,CAAC,iBAAiB,EAAE,EAAE,eAAe,CAAC,iBAAiB,EAAE,CAAC,CAAC,GAAG;IAC/H,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,UAAU,EAAE,OAAY,EAAE,KAAU,EAAE,UAAe,EAAE,QAAa,EAAE,YAAY,EAAE,EAAE,mCAAmC;;;EAoCrK"}

package/dist/hooks/workflow/useFetchWorkflowExecutions.js

@@ -0,0 +1,77 @@
+import { useAxios } from "../useAxios.js";
+import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { listWorkflowExecutions } from "../../api/workflow.js";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/workflow/useFetchWorkflowExecutions.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkflowExecutions
+*
+* Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+* workflow executions for a given workflow with cursor-based pagination.
+*
+* Automatically flattens all pages into a single `WorkflowExecution[]` via `select`.
+*
+* Note: `query.data` returns a flat `WorkflowExecution[]` with all fetched items merged across pages.
+*
+* @param workflowId - Workflow identifier whose executions to fetch (required).
+* @param filters - Filters applied to every page request. Must include a `workspace` filter.
+* @param order - Sorting applied to every page request.
+* @param projection - Single field to project: `"field"` returns only that field (others come
+*   back null), `"-field"` returns every field except that one. One field only — lists 500. Omitted when empty.
+* @param pageSize - Number of executions to fetch per page. Defaults to `10`.
+* @param queryOptions - TanStack Query options passed through to `useInfiniteQuery`.
+*
+* @returns
+*   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+*   - `queryKey`: the cache key used by React Query
+*
+* @example
+* ```ts
+* const { query } = useFetchWorkflowExecutions({
+*   workflowId: "wf-123",
+*   filters: [{ field: "workspace", value: "main" }],
+*   pageSize: 20,
+* });
+*
+* // Flat list of all fetched executions
+* const executions = query.data ?? [];
+* ```
+*/
+function useFetchWorkflowExecutions({ workflowId, filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+	const { api } = useAxios();
+	const queryKey = buildQueryKey(["workflow_executions", workflowId], filters);
+	const mergedQueryOptions = useMemo(() => ({
+		...defaultQueryOptions,
+		...queryOptions ?? {}
+	}), [queryOptions]);
+	return {
+		query: useInfiniteQuery({
+			queryKey,
+			initialPageParam: null,
+			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+			queryFn: async ({ pageParam }) => {
+				const queryFilter = buildQueryObject({
+					filters,
+					order,
+					projection,
+					pageSize,
+					pageToken: pageParam ?? void 0
+				});
+				return await listWorkflowExecutions(api, workflowId, queryFilter);
+			},
+			select: (data) => data.pages.flatMap((p) => p.workflow_executions),
+			...mergedQueryOptions
+		}),
+		queryKey
+	};
+}
+//#endregion
+export { useFetchWorkflowExecutions };
+
+//# sourceMappingURL=useFetchWorkflowExecutions.js.map

package/dist/hooks/workflow/useFetchWorkflowExecutions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflowExecutions.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflowExecutions.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useInfiniteQuery, type UseInfiniteQueryOptions, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { listWorkflowExecutions } from \"@/api/workflow\";\nimport type { FetchEntitiesParams } from \"@/types/entityQuery\";\nimport { buildQueryKey, buildQueryObject } from \"@/api/entityQuery\";\nimport type { WorkflowExecution, WorkflowExecutionListResponse } from \"@/types/workflow\";\n\ntype PageToken = string | null;\n\ntype InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkflowExecutionListResponse, Error, TData, QueryKey, PageToken>, \"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\">;\n\nexport type FetchInfiniteWorkflowExecutionProps = FetchEntitiesParams<WorkflowExecution[], InfiniteOptions<WorkflowExecution[]>> & {\n    workflowId: string;\n    pageSize?: number;\n};\n\nconst defaultQueryOptions: InfiniteOptions<WorkflowExecution[]> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkflowExecutions\n *\n * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve\n * workflow executions for a given workflow with cursor-based pagination.\n *\n * Automatically flattens all pages into a single `WorkflowExecution[]` via `select`.\n *\n * Note: `query.data` returns a flat `WorkflowExecution[]` with all fetched items merged across pages.\n *\n * @param workflowId - Workflow identifier whose executions to fetch (required).\n * @param filters - Filters applied to every page request. Must include a `workspace` filter.\n * @param order - Sorting applied to every page request.\n * @param projection - Single field to project: `\"field\"` returns only that field (others come\n *   back null), `\"-field\"` returns every field except that one. One field only — lists 500. Omitted when empty.\n * @param pageSize - Number of executions to fetch per page. Defaults to `10`.\n * @param queryOptions - TanStack Query options passed through to `useInfiniteQuery`.\n *\n * @returns\n *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)\n *   - `queryKey`: the cache key used by React Query\n *\n * @example\n * ```ts\n * const { query } = useFetchWorkflowExecutions({\n *   workflowId: \"wf-123\",\n *   filters: [{ field: \"workspace\", value: \"main\" }],\n *   pageSize: 20,\n * });\n *\n * // Flat list of all fetched executions\n * const executions = query.data ?? [];\n * ```\n */\nexport function useFetchWorkflowExecutions({ workflowId, filters = [], order = [], projection = \"\", pageSize = 10, queryOptions }: FetchInfiniteWorkflowExecutionProps) {\n    const { api } = useAxios();\n\n    const queryKey = buildQueryKey([\"workflow_executions\", workflowId], filters);\n\n    const mergedQueryOptions = useMemo<InfiniteOptions<WorkflowExecution[]>>(() => ({\n        ...defaultQueryOptions,\n        ...(queryOptions ?? {}),\n    }), [queryOptions]);\n\n    const query = useInfiniteQuery<WorkflowExecutionListResponse, Error, WorkflowExecution[], QueryKey, PageToken>({\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n\n        queryFn: async ({ pageParam }) => {\n            const queryFilter = buildQueryObject({\n                filters,\n                order,\n                projection,\n                pageSize,\n                pageToken: pageParam ?? undefined,\n            });\n\n            return await listWorkflowExecutions(api, workflowId, queryFilter);\n        },\n\n        select: (data) => data.pages.flatMap((p) => p.workflow_executions),\n\n        ...mergedQueryOptions,\n    });\n\n    return {\n        query,\n        queryKey,\n    };\n}\n"],"mappings":";;;;;;AAkBA,IAAM,sBAA4D;CAC9D,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,2BAA2B,EAAE,YAAY,UAAU,CAAC,GAAG,QAAQ,CAAC,GAAG,aAAa,IAAI,WAAW,IAAI,gBAAqD;CACpK,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW,cAAc,CAAC,uBAAuB,UAAU,GAAG,OAAO;CAE3E,MAAM,qBAAqB,eAAqD;EAC5E,GAAG;EACH,GAAI,gBAAgB,CAAC;CACzB,IAAI,CAAC,YAAY,CAAC;CAwBlB,OAAO;EACH,OAvBU,iBAAiG;GAC3G;GACA,kBAAkB;GAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;GAE5D,SAAS,OAAO,EAAE,gBAAgB;IAC9B,MAAM,cAAc,iBAAiB;KACjC;KACA;KACA;KACA;KACA,WAAW,aAAa,KAAA;IAC5B,CAAC;IAED,OAAO,MAAM,uBAAuB,KAAK,YAAY,WAAW;GACpE;GAEA,SAAS,SAAS,KAAK,MAAM,SAAS,MAAM,EAAE,mBAAmB;GAEjE,GAAG;EACP,CAGI;EACA;CACJ;AACJ"}

package/dist/hooks/workflow/useFetchWorkflows.d.ts

@@ -0,0 +1,47 @@
+import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
+import type { Workflow, WorkflowListResponse } from "../../types/workflow.d.ts";
+type PageToken = string | null;
+type InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkflowListResponse, Error, TData, QueryKey, PageToken>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">;
+export type FetchInfiniteWorkflowProps = {
+    workspace?: string;
+    pageSize?: number;
+    queryOptions?: InfiniteOptions<Workflow[]>;
+};
+/**
+ * useFetchWorkflows
+ *
+ * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+ * workflows with cursor-based pagination using the legacy method (workspace as query param).
+ *
+ * Automatically flattens all pages into a single `Workflow[]` via `select`.
+ *
+ * Note: `query.data` returns a flat `Workflow[]` with all fetched items merged across pages.
+ *
+ * @param {string} [workspace]
+ *   Current workspace name. Sent as a query param via the legacy method, required by some API configurations.
+ *
+ * @param {number} [pageSize=10]
+ *   Number of workflows to fetch per page.
+ *
+ * @param {InfiniteOptions<Workflow[]>} [queryOptions]
+ *   TanStack Query options passed through to `useInfiniteQuery`
+ *   (e.g., enabled, staleTime, gcTime, etc.).
+ *
+ * @returns {{ query, queryKey }}
+ *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+ *   - `queryKey`: the cache key used by React Query
+ *
+ * @example
+ * ```ts
+ * const { query } = useFetchWorkflows({ workspace: "ws-1", pageSize: 20 });
+ *
+ * // Flat list of all fetched workflows
+ * const workflows = query.data ?? [];
+ * ```
+ */
+export declare function useFetchWorkflows({ workspace, pageSize, queryOptions }: FetchInfiniteWorkflowProps): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<Workflow[], Error>;
+    queryKey: readonly unknown[];
+};
+export {};
+//# sourceMappingURL=useFetchWorkflows.d.ts.map

package/dist/hooks/workflow/useFetchWorkflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflows.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflows.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,uBAAuB,EAAE,KAAK,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAItG,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAEvE,KAAK,SAAS,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/B,KAAK,eAAe,CAAC,KAAK,IAAI,IAAI,CAAC,uBAAuB,CAAC,oBAAoB,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAC,UAAU,GAAG,SAAS,GAAG,kBAAkB,GAAG,kBAAkB,CAAC,CAAC;AAEtL,MAAM,MAAM,0BAA0B,GAAG;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,eAAe,CAAC,QAAQ,EAAE,CAAC,CAAC;CAC9C,CAAC;AAQF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,SAAS,EAAE,QAAa,EAAE,YAAY,EAAE,EAAE,0BAA0B;;;EA4BvG"}

package/dist/hooks/workflow/useFetchWorkflows.js

@@ -0,0 +1,67 @@
+import { useAxios } from "../useAxios.js";
+import { listWorkflows } from "../../api/workflow.js";
+import { useMemo } from "react";
+import { useInfiniteQuery } from "@tanstack/react-query";
+//#region src/hooks/workflow/useFetchWorkflows.ts
+var defaultQueryOptions = {
+	refetchOnMount: "always",
+	staleTime: 0,
+	gcTime: 0
+};
+/**
+* useFetchWorkflows
+*
+* Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
+* workflows with cursor-based pagination using the legacy method (workspace as query param).
+*
+* Automatically flattens all pages into a single `Workflow[]` via `select`.
+*
+* Note: `query.data` returns a flat `Workflow[]` with all fetched items merged across pages.
+*
+* @param {string} [workspace]
+*   Current workspace name. Sent as a query param via the legacy method, required by some API configurations.
+*
+* @param {number} [pageSize=10]
+*   Number of workflows to fetch per page.
+*
+* @param {InfiniteOptions<Workflow[]>} [queryOptions]
+*   TanStack Query options passed through to `useInfiniteQuery`
+*   (e.g., enabled, staleTime, gcTime, etc.).
+*
+* @returns {{ query, queryKey }}
+*   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)
+*   - `queryKey`: the cache key used by React Query
+*
+* @example
+* ```ts
+* const { query } = useFetchWorkflows({ workspace: "ws-1", pageSize: 20 });
+*
+* // Flat list of all fetched workflows
+* const workflows = query.data ?? [];
+* ```
+*/
+function useFetchWorkflows({ workspace, pageSize = 10, queryOptions }) {
+	const { api } = useAxios();
+	const queryKey = ["workflows", workspace ?? null];
+	const mergedQueryOptions = useMemo(() => ({
+		...defaultQueryOptions,
+		...queryOptions ?? {}
+	}), [queryOptions]);
+	return {
+		query: useInfiniteQuery({
+			queryKey,
+			initialPageParam: null,
+			getNextPageParam: (lastPage) => lastPage.next_page_token ?? void 0,
+			queryFn: async ({ pageParam }) => {
+				return await listWorkflows(api, workspace, pageSize, pageParam ?? void 0);
+			},
+			select: (data) => data.pages.flatMap((p) => p.workflows),
+			...mergedQueryOptions
+		}),
+		queryKey
+	};
+}
+//#endregion
+export { useFetchWorkflows };
+
+//# sourceMappingURL=useFetchWorkflows.js.map

package/dist/hooks/workflow/useFetchWorkflows.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFetchWorkflows.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflows.ts"],"sourcesContent":["import { useMemo } from \"react\";\nimport { useInfiniteQuery, type UseInfiniteQueryOptions, type QueryKey } from \"@tanstack/react-query\";\n\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { listWorkflows } from \"@/api/workflow\";\nimport type { Workflow, WorkflowListResponse } from \"@/types/workflow\";\n\ntype PageToken = string | null;\n\ntype InfiniteOptions<TData> = Omit<UseInfiniteQueryOptions<WorkflowListResponse, Error, TData, QueryKey, PageToken>,\"queryKey\" | \"queryFn\" | \"initialPageParam\" | \"getNextPageParam\">;\n\nexport type FetchInfiniteWorkflowProps = {\n    workspace?: string;\n    pageSize?: number;\n    queryOptions?: InfiniteOptions<Workflow[]>;\n};\n\nconst defaultQueryOptions: InfiniteOptions<Workflow[]> = {\n    refetchOnMount: \"always\",\n    staleTime: 0,\n    gcTime: 0,\n};\n\n/**\n * useFetchWorkflows\n *\n * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve\n * workflows with cursor-based pagination using the legacy method (workspace as query param).\n *\n * Automatically flattens all pages into a single `Workflow[]` via `select`.\n *\n * Note: `query.data` returns a flat `Workflow[]` with all fetched items merged across pages.\n *\n * @param {string} [workspace]\n *   Current workspace name. Sent as a query param via the legacy method, required by some API configurations.\n *\n * @param {number} [pageSize=10]\n *   Number of workflows to fetch per page.\n *\n * @param {InfiniteOptions<Workflow[]>} [queryOptions]\n *   TanStack Query options passed through to `useInfiniteQuery`\n *   (e.g., enabled, staleTime, gcTime, etc.).\n *\n * @returns {{ query, queryKey }}\n *   - `query`: the full `useInfiniteQuery` result (data, isLoading, hasNextPage, fetchNextPage, etc.)\n *   - `queryKey`: the cache key used by React Query\n *\n * @example\n * ```ts\n * const { query } = useFetchWorkflows({ workspace: \"ws-1\", pageSize: 20 });\n *\n * // Flat list of all fetched workflows\n * const workflows = query.data ?? [];\n * ```\n */\nexport function useFetchWorkflows({ workspace, pageSize = 10, queryOptions }: FetchInfiniteWorkflowProps) {\n    const { api } = useAxios();\n\n    const queryKey: QueryKey = [\"workflows\", workspace ?? null];\n\n    const mergedQueryOptions = useMemo<InfiniteOptions<Workflow[]>>(() => ({\n        ...defaultQueryOptions,\n        ...(queryOptions ?? {}),\n    }), [queryOptions]);\n\n    const query = useInfiniteQuery<WorkflowListResponse, Error, Workflow[], QueryKey, PageToken>({\n        queryKey,\n        initialPageParam: null,\n        getNextPageParam: (lastPage) => lastPage.next_page_token ?? undefined,\n\n        queryFn: async ({ pageParam }) => {\n            return await listWorkflows(api, workspace, pageSize, pageParam ?? undefined);\n        },\n\n        select: (data) => data.pages.flatMap((p) => p.workflows),\n\n        ...mergedQueryOptions,\n    });\n\n    return {\n        query,\n        queryKey,\n    };\n}\n"],"mappings":";;;;;AAiBA,IAAM,sBAAmD;CACrD,gBAAgB;CAChB,WAAW;CACX,QAAQ;AACZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,kBAAkB,EAAE,WAAW,WAAW,IAAI,gBAA4C;CACtG,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAqB,CAAC,aAAa,aAAa,IAAI;CAE1D,MAAM,qBAAqB,eAA4C;EACnE,GAAG;EACH,GAAI,gBAAgB,CAAC;CACzB,IAAI,CAAC,YAAY,CAAC;CAgBlB,OAAO;EACH,OAfU,iBAA+E;GACzF;GACA,kBAAkB;GAClB,mBAAmB,aAAa,SAAS,mBAAmB,KAAA;GAE5D,SAAS,OAAO,EAAE,gBAAgB;IAC9B,OAAO,MAAM,cAAc,KAAK,WAAW,UAAU,aAAa,KAAA,CAAS;GAC/E;GAEA,SAAS,SAAS,KAAK,MAAM,SAAS,MAAM,EAAE,SAAS;GAEvD,GAAG;EACP,CAGI;EACA;CACJ;AACJ"}

package/dist/hooks/workflow/useRunWorkflow.d.ts

@@ -0,0 +1,30 @@
+import type { AnyRecord } from "../../types/anyRecord.d.ts";
+import type { PollWorkflowExecutionOptions } from "../../api/workflow.js";
+type RunWorkflowProps = {
+    id: string;
+    workspace: string;
+    parameters: AnyRecord;
+    pollOptions?: PollWorkflowExecutionOptions;
+};
+/**
+ * useRunWorkflow
+ *
+ * TanStack Query mutations to run a workflow. Synchronous execution (`synchronous: true`) is
+ * intentionally not used; instead the workflow is started asynchronously and, when the result
+ * is needed, its execution is polled until it reaches a terminal state.
+ *
+ * - `runAsync`: starts the workflow and returns immediately (fire-and-forget). Use when you do
+ *   not need to wait for completion or consume the output.
+ * - `runAndGetResult`: starts the workflow, polls until it finishes, then fetches the output of
+ *   the ender worker. Resolves with `{ execution, workerExecution, result }`; `result` is `null`
+ *   when the workflow produces no output. This is the replacement for the old synchronous flow.
+ *
+ * Both surface the standard mutation helpers (`mutate`, `mutateAsync`, `isPending`, `data`, ...)
+ * and report failures through `useAppAlert`.
+ */
+export declare const useRunWorkflow: () => {
+    runAsync: import("@tanstack/react-query").UseMutationResult<AnyRecord, Error, RunWorkflowProps, unknown>;
+    runAndGetResult: import("@tanstack/react-query").UseMutationResult<import("../../api/workflow.js").WorkflowResult, Error, RunWorkflowProps, unknown>;
+};
+export {};
+//# sourceMappingURL=useRunWorkflow.d.ts.map