@everysk/apps-sdk 0.2.0 → 0.3.0-beta-20261016180126

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

@@ -1,40 +1,23 @@
 import type { WorkflowExecution } from "../../types/workflow.d.ts";
-import type { EntityQueryOptions } from "../../types/entityQuery.d.ts";
-export type FetchWorkflowExecutionProps<TData = WorkflowExecution, TSelected = TData> = {
+import type { FetchEntityProps } from "../../types/entityQuery.d.ts";
+export type FetchWorkflowExecutionProps<TData = WorkflowExecution, TSelected = TData> = FetchEntityProps<TData, TSelected> & {
     workflowId: string;
     workflowExecutionId: string;
     workspace: string;
-    queryOptions?: EntityQueryOptions<TData, TSelected>;
 };
 /**
  * useFetchWorkflowExecution
  *
- * Data-fetching hook built on TanStack Query to retrieve a single workflow execution.
+ * Fetches one execution of a workflow; `data` is the execution, or whatever `select` makes of
+ * it. Idle while an id is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.
  *
- * 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
- * ```
+ * @param {FetchWorkflowExecutionProps} props - `workflowId`, `workflowExecutionId`, `workspace`,
+ *   `select` and TanStack `queryOptions`.
+ * @returns {object} The `useQuery` result, plus `queryKey`.
  */
-export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecutionId, workspace, queryOptions }: FetchWorkflowExecutionProps) => {
+export declare const useFetchWorkflowExecution: <TSelected = WorkflowExecution>({ workflowId, workflowExecutionId, workspace, select, queryOptions, }: FetchWorkflowExecutionProps<WorkflowExecution, TSelected>) => {
     queryKey: string[];
-    data: WorkflowExecution;
+    data: TSelected;
     error: Error;
     isError: true;
     isPending: false;
@@ -57,11 +40,11 @@ export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecution
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
-    data: WorkflowExecution;
+    data: TSelected;
     error: null;
     isError: false;
     isPending: false;
@@ -84,7 +67,7 @@ export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecution
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -111,7 +94,7 @@ export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecution
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -138,7 +121,7 @@ export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecution
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
@@ -165,11 +148,11 @@ export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecution
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 } | {
     queryKey: string[];
-    data: WorkflowExecution;
+    data: TSelected;
     isError: false;
     error: null;
     isPending: false;
@@ -192,7 +175,7 @@ export declare const useFetchWorkflowExecution: ({ workflowId, workflowExecution
     isRefetching: boolean;
     isStale: boolean;
     isEnabled: boolean;
-    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<WorkflowExecution, Error>>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<TSelected, Error>>;
     fetchStatus: import("@tanstack/query-core").FetchStatus;
 };
 //# sourceMappingURL=useFetchWorkflowExecution.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkflowExecution.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflowExecution.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,2BAA2B,CACnC,KAAK,GAAG,iBAAiB,EACzB,SAAS,GAAG,KAAK,IACjB,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAAI,SAAS,GAAG,iBAAiB,EAAE,uEAMtE,2BAA2B,CAAC,iBAAiB,EAAE,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgB3D,CAAC"}

package/dist/hooks/workflow/useFetchWorkflowExecution.js

@@ -1,65 +1,35 @@
-import { useAppAlert } from "../../contexts/appAlertContext/useAppAlert.js";
 import { useAxios } from "../useAxios.js";
+import { useEntityQuery } from "../useEntityQuery.js";
+import { missingWorkspaceError } from "../../api/entityQuery.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`.
+* Fetches one execution of a workflow; `data` is the execution, or whatever `select` makes of
+* it. Idle while an id is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.
 *
-* Example:
-* ```ts
-* const { data, isLoading } = useFetchWorkflowExecution({
-*   workflowId: "wf-123",
-*   workflowExecutionId: "exec-456",
-*   workspace: "main",
-* });
-* // data -> WorkflowExecution
-* ```
+* @param {FetchWorkflowExecutionProps} props - `workflowId`, `workflowExecutionId`, `workspace`,
+*   `select` and TanStack `queryOptions`.
+* @returns {object} The `useQuery` result, plus `queryKey`.
 */
-var useFetchWorkflowExecution = ({ workflowId, workflowExecutionId, workspace, queryOptions = defaultQueryOptions }) => {
+var useFetchWorkflowExecution = ({ workflowId, workflowExecutionId, workspace, select, queryOptions }) => {
 	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,
+		...useEntityQuery({
+			queryKey,
+			fetchEntity: (signal) => getWorkflowExecution(api, workflowId, workflowExecutionId, workspace, signal),
+			select,
+			enabled: Boolean(workflowId) && Boolean(workflowExecutionId),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchWorkflowExecution"),
+			queryOptions
+		}),
 		queryKey
 	};
 };

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkflowExecution.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflowExecution.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityQuery } from \"@/hooks/useEntityQuery\";\nimport { missingWorkspaceError } from \"@/api/entityQuery\";\nimport { getWorkflowExecution } from \"@/api/workflow\";\nimport type { WorkflowExecution } from \"@/types/workflow\";\nimport type { FetchEntityProps } from \"@/types/entityQuery\";\n\nexport type FetchWorkflowExecutionProps<\n    TData = WorkflowExecution,\n    TSelected = TData,\n> = FetchEntityProps<TData, TSelected> & {\n    workflowId: string;\n    workflowExecutionId: string;\n    workspace: string;\n};\n\n/**\n * useFetchWorkflowExecution\n *\n * Fetches one execution of a workflow; `data` is the execution, or whatever `select` makes of\n * it. Idle while an id is empty; fails loudly, without a request, while `workspace` is. A failure is shown as an error alert.\n *\n * @param {FetchWorkflowExecutionProps} props - `workflowId`, `workflowExecutionId`, `workspace`,\n *   `select` and TanStack `queryOptions`.\n * @returns {object} The `useQuery` result, plus `queryKey`.\n */\nexport const useFetchWorkflowExecution = <TSelected = WorkflowExecution>({\n    workflowId,\n    workflowExecutionId,\n    workspace,\n    select,\n    queryOptions,\n}: FetchWorkflowExecutionProps<WorkflowExecution, TSelected>) => {\n    const { api } = useAxios();\n\n    const queryKey = [\"workflow_execution\", workflowId, workflowExecutionId, workspace];\n\n    const query = useEntityQuery<WorkflowExecution, TSelected>({\n        queryKey,\n        fetchEntity: (signal) =>\n            getWorkflowExecution(api, workflowId, workflowExecutionId, workspace, signal),\n        select,\n        enabled: Boolean(workflowId) && Boolean(workflowExecutionId),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchWorkflowExecution\"),\n        queryOptions,\n    });\n\n    return { ...query, queryKey };\n};\n"],"mappings":";;;;;;;;;;;;;;;AA0BA,IAAa,6BAA4D,EACrE,YACA,qBACA,WACA,QACA,mBAC6D;CAC7D,MAAM,EAAE,QAAQ,SAAS;CAEzB,MAAM,WAAW;EAAC;EAAsB;EAAY;EAAqB;CAAS;CAYlF,OAAO;EAAE,GAVK,eAA6C;GACvD;GACA,cAAc,WACV,qBAAqB,KAAK,YAAY,qBAAqB,WAAW,MAAM;GAChF;GACA,SAAS,QAAQ,UAAU,KAAK,QAAQ,mBAAmB;GAC3D,aAAa,YAAY,KAAA,IAAY,sBAAsB,2BAA2B;GACtF;EACJ,CAEY;EAAO;CAAS;AAChC"}

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

@@ -1,49 +1,35 @@
-import { type UseInfiniteQueryOptions, type QueryKey } from "@tanstack/react-query";
-import type { FetchEntitiesParams } from "../../types/entityQuery.d.ts";
+import type { FetchEntitiesProps, ListCache } 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[]>> & {
+/** The query cache of `useFetchWorkflowExecutions`, for typing `setQueryData`. */
+export type WorkflowExecutionsCache = ListCache<WorkflowExecutionListResponse>;
+export type FetchWorkflowExecutionsProps<TData = WorkflowExecution[]> = FetchEntitiesProps<WorkflowExecution, TData, WorkflowExecutionListResponse> & {
     workflowId: string;
-    pageSize?: number;
+    workspace: string;
+    /** Only the executions this worker took part in. */
+    workerId?: string;
+    /** Include each execution's `resume`, the per-worker summary. */
+    withResume?: boolean;
 };
 /**
  * useFetchWorkflowExecutions
  *
- * Data-fetching hook built on TanStack Query's `useInfiniteQuery` to retrieve
- * workflow executions for a given workflow with cursor-based pagination.
+ * Lists the executions of one workflow, newest first, with cursor pagination; `query.data` is
+ * every loaded page merged, or whatever `select` makes of it. `select`, `fetchAllPages` and the
+ * missing-workspace error behave as in `useFetchDatastores`. Idle while `workflowId` is empty.
  *
- * Automatically flattens all pages into a single `WorkflowExecution[]` via `select`.
+ * The endpoint takes no filters, order or projection: only a worker id and `withResume`. It used
+ * to accept them as props and send them in a JSON query the endpoint ignores, along with the
+ * cursor, so every "next page" was the first one.
  *
- * Note: `query.data` returns a flat `WorkflowExecution[]` with all fetched items merged across pages.
+ * The key starts with `["workflow_executions", workflowId]`, which is what apps invalidate to
+ * refresh the list after running a workflow.
  *
- * @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 ?? [];
- * ```
+ * @param {FetchWorkflowExecutionsProps} props - Workflow id, workspace, worker id,
+ *   `withResume`, page size, `select`, `fetchAllPages`, `queryOptions`.
+ * @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.
  */
-export declare function useFetchWorkflowExecutions({ workflowId, filters, order, projection, pageSize, queryOptions }: FetchInfiniteWorkflowExecutionProps): {
-    query: import("@tanstack/react-query").UseInfiniteQueryResult<WorkflowExecution[], Error>;
+export declare function useFetchWorkflowExecutions<TData = WorkflowExecution[]>({ workflowId, workspace, workerId, withResume, pageSize, select, fetchAllPages, queryOptions, }: FetchWorkflowExecutionsProps<TData>): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<TData, Error>;
     queryKey: unknown[];
 };
-export {};
 //# sourceMappingURL=useFetchWorkflowExecutions.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkflowExecutions.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflowExecutions.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,6BAA6B,EAAE,MAAM,kBAAkB,CAAC;AAEzF,kFAAkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,SAAS,CAAC,6BAA6B,CAAC,CAAC;AAE/E,MAAM,MAAM,4BAA4B,CAAC,KAAK,GAAG,iBAAiB,EAAE,IAAI,kBAAkB,CACtF,iBAAiB,EACjB,KAAK,EACL,6BAA6B,CAChC,GAAG;IACA,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,UAAU,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,GAAG,iBAAiB,EAAE,EAAE,EACpE,UAAU,EACV,SAAS,EACT,QAAQ,EACR,UAAU,EACV,QAAa,EACb,MAAM,EACN,aAAqB,EACrB,YAAY,GACf,EAAE,4BAA4B,CAAC,KAAK,CAAC;;;EAmCrC"}

package/dist/hooks/workflow/useFetchWorkflowExecutions.js

@@ -1,72 +1,59 @@
 import { useAxios } from "../useAxios.js";
-import { buildQueryKey, buildQueryObject } from "../../api/entityQuery.js";
+import { useEntityInfiniteQuery } from "../useEntityInfiniteQuery.js";
+import { buildQueryKey, missingWorkspaceError } 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.
+* Lists the executions of one workflow, newest first, with cursor pagination; `query.data` is
+* every loaded page merged, or whatever `select` makes of it. `select`, `fetchAllPages` and the
+* missing-workspace error behave as in `useFetchDatastores`. Idle while `workflowId` is empty.
 *
-* Automatically flattens all pages into a single `WorkflowExecution[]` via `select`.
+* The endpoint takes no filters, order or projection: only a worker id and `withResume`. It used
+* to accept them as props and send them in a JSON query the endpoint ignores, along with the
+* cursor, so every "next page" was the first one.
 *
-* Note: `query.data` returns a flat `WorkflowExecution[]` with all fetched items merged across pages.
+* The key starts with `["workflow_executions", workflowId]`, which is what apps invalidate to
+* refresh the list after running a workflow.
 *
-* @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 ?? [];
-* ```
+* @param {FetchWorkflowExecutionsProps} props - Workflow id, workspace, worker id,
+*   `withResume`, page size, `select`, `fetchAllPages`, `queryOptions`.
+* @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.
 */
-function useFetchWorkflowExecutions({ workflowId, filters = [], order = [], projection = "", pageSize = 10, queryOptions }) {
+function useFetchWorkflowExecutions({ workflowId, workspace, workerId, withResume, pageSize = 10, select, fetchAllPages = false, queryOptions }) {
 	const { api } = useAxios();
-	const queryKey = buildQueryKey(["workflow_executions", workflowId], filters);
-	const mergedQueryOptions = useMemo(() => ({
-		...defaultQueryOptions,
-		...queryOptions ?? {}
-	}), [queryOptions]);
+	const filters = [...workerId ? [{
+		field: "worker_id",
+		value: workerId
+	}] : [], ...withResume !== void 0 ? [{
+		field: "with_resume",
+		value: withResume
+	}] : []];
+	const queryKey = buildQueryKey([
+		"workflow_executions",
+		workflowId,
+		workspace
+	], filters, {
+		pageSize,
+		fetchAllPages
+	});
 	return {
-		query: useInfiniteQuery({
+		query: useEntityInfiniteQuery({
 			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
+			itemsKey: "workflow_executions",
+			fetchPage: (pageToken, signal) => listWorkflowExecutions(api, workflowId, {
+				workspace,
+				pageSize,
+				pageToken: pageToken ?? void 0,
+				workerId,
+				withResume
+			}, signal),
+			select,
+			fetchAllPages,
+			enabled: Boolean(workflowId),
+			configError: workspace ? void 0 : missingWorkspaceError("useFetchWorkflowExecutions"),
+			queryOptions
 		}),
 		queryKey
 	};

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkflowExecutions.js","names":[],"sources":["../../../src/hooks/workflow/useFetchWorkflowExecutions.ts"],"sourcesContent":["import { useAxios } from \"@/hooks/useAxios\";\nimport { useEntityInfiniteQuery } from \"@/hooks/useEntityInfiniteQuery\";\nimport { listWorkflowExecutions } from \"@/api/workflow\";\nimport type { FetchEntitiesProps, ListCache } from \"@/types/entityQuery\";\nimport { buildQueryKey, missingWorkspaceError } from \"@/api/entityQuery\";\nimport type { WorkflowExecution, WorkflowExecutionListResponse } from \"@/types/workflow\";\n\n/** The query cache of `useFetchWorkflowExecutions`, for typing `setQueryData`. */\nexport type WorkflowExecutionsCache = ListCache<WorkflowExecutionListResponse>;\n\nexport type FetchWorkflowExecutionsProps<TData = WorkflowExecution[]> = FetchEntitiesProps<\n    WorkflowExecution,\n    TData,\n    WorkflowExecutionListResponse\n> & {\n    workflowId: string;\n    workspace: string;\n    /** Only the executions this worker took part in. */\n    workerId?: string;\n    /** Include each execution's `resume`, the per-worker summary. */\n    withResume?: boolean;\n};\n\n/**\n * useFetchWorkflowExecutions\n *\n * Lists the executions of one workflow, newest first, with cursor pagination; `query.data` is\n * every loaded page merged, or whatever `select` makes of it. `select`, `fetchAllPages` and the\n * missing-workspace error behave as in `useFetchDatastores`. Idle while `workflowId` is empty.\n *\n * The endpoint takes no filters, order or projection: only a worker id and `withResume`. It used\n * to accept them as props and send them in a JSON query the endpoint ignores, along with the\n * cursor, so every \"next page\" was the first one.\n *\n * The key starts with `[\"workflow_executions\", workflowId]`, which is what apps invalidate to\n * refresh the list after running a workflow.\n *\n * @param {FetchWorkflowExecutionsProps} props - Workflow id, workspace, worker id,\n *   `withResume`, page size, `select`, `fetchAllPages`, `queryOptions`.\n * @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.\n */\nexport function useFetchWorkflowExecutions<TData = WorkflowExecution[]>({\n    workflowId,\n    workspace,\n    workerId,\n    withResume,\n    pageSize = 10,\n    select,\n    fetchAllPages = false,\n    queryOptions,\n}: FetchWorkflowExecutionsProps<TData>) {\n    const { api } = useAxios();\n\n    // The endpoint's two filters go in the key as filters, so a list per worker gets its own entry.\n    const filters = [\n        ...(workerId ? [{ field: \"worker_id\", value: workerId }] : []),\n        ...(withResume !== undefined ? [{ field: \"with_resume\", value: withResume }] : []),\n    ];\n    const queryKey = buildQueryKey([\"workflow_executions\", workflowId, workspace], filters, {\n        pageSize,\n        fetchAllPages,\n    });\n\n    const query = useEntityInfiniteQuery<\n        WorkflowExecutionListResponse,\n        \"workflow_executions\",\n        TData\n    >({\n        queryKey,\n        itemsKey: \"workflow_executions\",\n        fetchPage: (pageToken, signal) =>\n            listWorkflowExecutions(\n                api,\n                workflowId,\n                { workspace, pageSize, pageToken: pageToken ?? undefined, workerId, withResume },\n                signal,\n            ),\n        select,\n        fetchAllPages,\n        enabled: Boolean(workflowId),\n        configError: workspace ? undefined : missingWorkspaceError(\"useFetchWorkflowExecutions\"),\n        queryOptions,\n    });\n\n    return { query, queryKey };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAyCA,SAAgB,2BAAwD,EACpE,YACA,WACA,UACA,YACA,WAAW,IACX,QACA,gBAAgB,OAChB,gBACoC;CACpC,MAAM,EAAE,QAAQ,SAAS;CAGzB,MAAM,UAAU,CACZ,GAAI,WAAW,CAAC;EAAE,OAAO;EAAa,OAAO;CAAS,CAAC,IAAI,CAAC,GAC5D,GAAI,eAAe,KAAA,IAAY,CAAC;EAAE,OAAO;EAAe,OAAO;CAAW,CAAC,IAAI,CAAC,CACpF;CACA,MAAM,WAAW,cAAc;EAAC;EAAuB;EAAY;CAAS,GAAG,SAAS;EACpF;EACA;CACJ,CAAC;CAuBD,OAAO;EAAE,OArBK,uBAIZ;GACE;GACA,UAAU;GACV,YAAY,WAAW,WACnB,uBACI,KACA,YACA;IAAE;IAAW;IAAU,WAAW,aAAa,KAAA;IAAW;IAAU;GAAW,GAC/E,MACJ;GACJ;GACA;GACA,SAAS,QAAQ,UAAU;GAC3B,aAAa,YAAY,KAAA,IAAY,sBAAsB,4BAA4B;GACvF;EACJ,CAES;EAAO;CAAS;AAC7B"}

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

@@ -1,47 +1,30 @@
-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[]>;
+import type { FetchEntitiesProps, ListCache } from "../../types/entityQuery.d.ts";
+/** The query cache of `useFetchWorkflows`, for typing `setQueryData`. */
+export type WorkflowsCache = ListCache<WorkflowListResponse>;
+export type FetchWorkflowsProps<TData = Workflow[]> = FetchEntitiesProps<Workflow, TData, WorkflowListResponse> & {
+    /** Workspace to list. Required: without one the API reads `main`, not the account. */
+    workspace: string;
+    /** A name prefix, an id, `#tag #tag` (every tag), or `&link_uid`. */
+    search?: string;
 };
 /**
  * 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).
+ * Lists workflows with cursor pagination; `query.data` is every loaded page merged, or
+ * whatever `select` makes of it. `select` and `fetchAllPages` behave as in
+ * `useFetchDatastores`. This endpoint takes a workspace and a text `search` rather than
+ * filters.
  *
- * Automatically flattens all pages into a single `Workflow[]` via `select`.
+ * A missing workspace fails loudly, without a request, as in every other hook. This hook used to
+ * allow one, documented as listing the account's workflows; the API reads `main` instead.
  *
- * 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 ?? [];
- * ```
+ * @param {FetchWorkflowsProps} props - Workspace, search, page size, `select`,
+ *   `fetchAllPages` and TanStack `queryOptions`.
+ * @returns {object} `query` (the `useInfiniteQuery` result) and `queryKey`.
  */
-export declare function useFetchWorkflows({ workspace, pageSize, queryOptions }: FetchInfiniteWorkflowProps): {
-    query: import("@tanstack/react-query").UseInfiniteQueryResult<Workflow[], Error>;
-    queryKey: readonly unknown[];
+export declare function useFetchWorkflows<TData = Workflow[]>({ workspace, search, pageSize, select, fetchAllPages, queryOptions, }: FetchWorkflowsProps<TData>): {
+    query: import("@tanstack/react-query").UseInfiniteQueryResult<TData, Error>;
+    queryKey: unknown[];
 };
-export {};
 //# sourceMappingURL=useFetchWorkflows.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"useFetchWorkflows.d.ts","sourceRoot":"","sources":["../../../src/hooks/workflow/useFetchWorkflows.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEzE,yEAAyE;AACzE,MAAM,MAAM,cAAc,GAAG,SAAS,CAAC,oBAAoB,CAAC,CAAC;AAE7D,MAAM,MAAM,mBAAmB,CAAC,KAAK,GAAG,QAAQ,EAAE,IAAI,kBAAkB,CACpE,QAAQ,EACR,KAAK,EACL,oBAAoB,CACvB,GAAG;IACA,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,GAAG,QAAQ,EAAE,EAAE,EAClD,SAAS,EACT,MAAM,EACN,QAAa,EACb,MAAM,EACN,aAAqB,EACrB,YAAY,GACf,EAAE,mBAAmB,CAAC,KAAK,CAAC;;;EAwB5B"}