@burdenoff/fluidgrids-fe-sdk 2026.1105.4 → 2026.1107.1

package/dist/workflow-builder-C261exmL.d.ts

@@ -0,0 +1,688 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ApolloClient } from '@apollo/client/core';
+import { ReactNode } from 'react';
+import { Edge, Node, NodeChange, EdgeChange, Connection } from '@xyflow/react';
+import * as zustand from 'zustand';
+
+declare const FLUIDGRIDS_EVENTS_VERSION = "1.0.0";
+type FluidGridsErrorSource = "workflow:save" | "workflow:activate" | "run:start";
+interface FluidGridsEventMap {
+    "workflow:saved": {
+        workflowKey: string;
+        version?: string;
+        id?: string;
+    };
+    "workflow:activated": {
+        workflowKey: string;
+        version?: string;
+    };
+    "run:started": {
+        runId: string;
+        workflowKey?: string;
+        mode?: string;
+    };
+    "run:completed": {
+        runId: string;
+        status: string;
+        workflowKey?: string;
+    };
+    "node:selected": {
+        nodeId: string | null;
+        nodeType?: string;
+    };
+    error: {
+        source: FluidGridsErrorSource;
+        message: string;
+        code?: string;
+    };
+    "auth:failed": {
+        message: string;
+    };
+}
+type FluidGridsEventName = keyof FluidGridsEventMap;
+type FluidGridsEventPayload<K extends FluidGridsEventName> = FluidGridsEventMap[K];
+declare const FLUIDGRIDS_EVENT_NAMES: readonly FluidGridsEventName[];
+type FluidGridsEventArgs = {
+    [K in FluidGridsEventName]: [name: K, payload: FluidGridsEventMap[K]];
+}[FluidGridsEventName];
+type FluidGridsEventHandler = (...args: FluidGridsEventArgs) => void;
+
+type FluidGridsThemeMode = "light" | "dark";
+interface FluidGridsThemeColors {
+    bgCanvas?: string;
+    bgSurface?: string;
+    bgElevated?: string;
+    bgSunken?: string;
+    textPrimary?: string;
+    textSecondary?: string;
+    textMuted?: string;
+    borderDefault?: string;
+    borderSubtle?: string;
+    borderStrong?: string;
+    primary?: string;
+    primaryHover?: string;
+    primaryActive?: string;
+    primaryText?: string;
+    success?: string;
+    warning?: string;
+    error?: string;
+    info?: string;
+}
+interface FluidGridsThemeRadius {
+    base?: string;
+    card?: string;
+    button?: string;
+    input?: string;
+}
+interface FluidGridsThemeFont {
+    body?: string;
+    heading?: string;
+    mono?: string;
+}
+interface FluidGridsThemeTokens {
+    mode?: FluidGridsThemeMode;
+    colors?: FluidGridsThemeColors;
+    radius?: FluidGridsThemeRadius;
+    font?: FluidGridsThemeFont;
+}
+type FluidGridsTheme = FluidGridsThemeMode | FluidGridsThemeTokens;
+type FluidGridsThemeValueKind = "color" | "length" | "font";
+interface FluidGridsThemeTokenMapping {
+    kind: FluidGridsThemeValueKind;
+    cssVariables: readonly string[];
+}
+type FluidGridsThemeTokenKey = `colors.${keyof FluidGridsThemeColors & string}` | `radius.${keyof FluidGridsThemeRadius & string}` | `font.${keyof FluidGridsThemeFont & string}`;
+declare const FLUIDGRIDS_THEME_TOKEN_MAP: Readonly<Record<FluidGridsThemeTokenKey, FluidGridsThemeTokenMapping>>;
+declare function themeToCssVariables(theme: FluidGridsTheme | null | undefined): Record<string, string>;
+declare function applyFluidGridsTheme(theme: FluidGridsTheme | null | undefined): () => void;
+
+interface WorkflowSavedResult {
+    dbId: string;
+    workflowKey: string;
+    version: string;
+    name: string;
+    description?: string;
+    operation: "created" | "updated" | "versioned";
+}
+interface FluidGridsRefreshedTokens {
+    authToken?: string;
+    workspaceToken?: string;
+}
+interface FluidGridsAuthConfig {
+    onTokenExpired?: () => Promise<string | FluidGridsRefreshedTokens>;
+}
+interface FluidGridsConfig {
+    apiGatewayUrl: string;
+    globalApiUrl?: string;
+    authToken?: string;
+    workspaceId: string;
+    workspaceToken?: string;
+    tenantId?: string;
+    organizationId?: string;
+    fluidgridFrontendUrl?: string;
+    productId?: string;
+    productName?: string;
+    trustedOrigins?: string[];
+    onWorkflowSaved?: (result: WorkflowSavedResult) => void | Promise<void>;
+    theme?: FluidGridsTheme;
+    auth?: FluidGridsAuthConfig;
+    onEvent?: FluidGridsEventHandler;
+}
+declare const config: FluidGridsConfig;
+declare function getFluidGridsConfig(): FluidGridsConfig;
+declare function setFluidGridsConfig(newConfig: Partial<FluidGridsConfig>): void;
+declare function resetFluidGridsConfig(): void;
+declare function getGraphQLEndpoint(baseUrl?: string): string;
+declare function resetFluidGridsExecutionState(): void;
+
+interface FluidGridsProviderProps {
+    apiGatewayUrl?: string;
+    globalApiUrl?: string;
+    authToken?: string;
+    workspaceToken?: string;
+    workspaceId: string;
+    productId?: string;
+    userId?: string;
+    trustedOrigins?: string[];
+    tenantId?: string;
+    organizationId?: string;
+    workspaceClient?: ApolloClient;
+    globalClient?: ApolloClient;
+    apolloClient?: ApolloClient;
+    t?: (key: string, fallback: string) => string;
+    theme?: FluidGridsTheme;
+    auth?: FluidGridsAuthConfig;
+    onEvent?: FluidGridsEventHandler;
+    children: ReactNode;
+}
+interface FluidGridsContextValue {
+    apiGatewayUrl?: string;
+    globalApiUrl?: string;
+    authToken?: string;
+    workspaceId: string;
+    productId?: string;
+    userId?: string;
+    trustedOrigins?: string[];
+    tenantId?: string;
+    organizationId?: string;
+    workspaceClient?: ApolloClient;
+    globalClient?: ApolloClient;
+    t?: (key: string, fallback: string) => string;
+}
+declare function FluidGridsProvider({ apiGatewayUrl, globalApiUrl, authToken, workspaceToken, workspaceId, productId, userId, trustedOrigins, tenantId, organizationId, t, theme, auth, onEvent, workspaceClient: externalWorkspaceClient, globalClient: externalGlobalClient, apolloClient: legacyClient, children, }: FluidGridsProviderProps): react_jsx_runtime.JSX.Element;
+declare function useFluidGridsContext(): FluidGridsContextValue;
+
+type ExtendedNodeType = "trigger:api" | "end" | "internal:if" | "internal:switch" | "internal:loop" | "internal:merge" | "internal:set" | "internal:filter" | "internal:aggregate" | "internal:wait" | "internal:noop" | "internal:subworkflow" | string;
+interface FlowNodeData {
+    label: string;
+    deletable?: boolean;
+    nodeType?: string;
+    config?: Record<string, unknown>;
+    disabled?: boolean;
+    errorConfig?: INodeErrorConfig;
+    notes?: string;
+    executionSettings?: INodeExecutionSettings;
+    [key: string]: unknown;
+}
+interface FlowNode extends Node {
+    type: ExtendedNodeType;
+    data: FlowNodeData;
+    deletable?: boolean;
+}
+interface FlowEdge extends Edge {
+    type?: "deletable" | "smoothstep" | "default" | string;
+    condition?: EdgeCondition;
+    mapping?: EdgeMapping;
+}
+interface EdgeCondition {
+    rules: ConditionRule[];
+    logic: "and" | "or";
+}
+interface ConditionRule {
+    field: string;
+    operator: string;
+    value: string;
+}
+type MappingValue = string | number | boolean | null | MappingValue[] | {
+    [key: string]: MappingValue;
+};
+interface EdgeMapping {
+    definition: Record<string, MappingValue>;
+    comment?: string;
+}
+interface NodeAdapterManifest {
+    name: string;
+    required?: boolean;
+    type?: string;
+    maxConnections?: number | null;
+    filter?: {
+        kind?: string[];
+        excludeNodes?: string[];
+    };
+}
+interface NodeManifest {
+    nodeType: string;
+    name: string;
+    description?: string;
+    kind?: string[];
+    version: string;
+    operations?: {
+        operations?: unknown[];
+    };
+    icon?: string;
+    category?: string;
+    nodeAdapters?: NodeAdapterManifest[];
+    supportsAdapterMode?: boolean;
+    adapterOutputType?: string;
+    docsUrl?: string;
+}
+interface NodeEndpointConfig {
+    id: string;
+    nodeType: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    category?: string;
+    manifest?: NodeManifest;
+}
+
+interface INodeRetryConfig {
+    maxRetries: number;
+    retryDelay: number;
+    backoffMultiplier?: number;
+    maxDelay?: number;
+    retryOnErrorTypes?: string[];
+}
+interface INodeTimeoutConfig {
+    duration: number;
+    onTimeout?: "stop" | "continue" | "branch";
+    timeoutBranchId?: string;
+}
+interface INodeErrorConfig {
+    onError?: "stop" | "continue" | "branch";
+    errorBranchId?: string;
+    retryConfig?: INodeRetryConfig;
+    timeout?: INodeTimeoutConfig;
+}
+interface INodeExecutionSettings {
+    alwaysOutputData?: boolean;
+    executeOnce?: boolean;
+    runOn?: {
+        kind: "runner";
+        runnerId: string;
+    };
+}
+interface WorkflowDataSaving {
+    saveSuccessExecutions?: boolean;
+    saveFailedExecutions?: boolean;
+    saveManualExecutions?: boolean;
+}
+interface WorkflowDataPrivacy {
+    doNotStoreRunData?: boolean;
+    redactFields?: string[];
+}
+interface WorkflowRetention {
+    maxAgeDays?: number;
+    maxRuns?: number;
+}
+interface IWorkflowConfig {
+    maxParallelism?: number;
+    timeout?: number;
+    retry?: {
+        maxAttempts: number;
+        backoffMultiplier?: number;
+        initialDelay?: number;
+    };
+    onError?: "stop" | "continue" | "retry";
+    errorWorkflowKey?: string;
+    dataSaving?: WorkflowDataSaving;
+    retention?: WorkflowRetention;
+    dataPrivacy?: WorkflowDataPrivacy;
+}
+interface WorkflowDefinition {
+    id: string;
+    workflowKey: string;
+    version: string;
+    name: string;
+    description?: string;
+    alias?: string;
+    status?: "draft" | "active" | "archived";
+    definitionJson?: WorkflowDefinitionJson;
+    createdAt?: string;
+    updatedAt?: string;
+    createdBy?: string;
+    revision?: number;
+    updatedById?: string | null;
+}
+interface WorkflowDefinitionJson {
+    key: string;
+    name: string;
+    description?: string;
+    workflow_type?: string;
+    data: WorkflowData;
+    meta?: Record<string, unknown>;
+    tags?: string[];
+    config?: IWorkflowConfig;
+}
+interface WorkflowData {
+    id: string;
+    workflowKey: string;
+    name: string;
+    version: string;
+    alias?: string;
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+    sidebar: SidebarState;
+}
+interface SidebarState {
+    active: "node-properties" | "store-browse" | "none";
+    panels: {
+        nodeProperties: {
+            selectedNode: {
+                id: string;
+                type: string;
+            } | null;
+        };
+    };
+}
+interface Tag {
+    value: string;
+    label: string;
+    color: string;
+}
+
+type RunStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "timeout";
+type NodeStatus = "idle" | "pending" | "running" | "success" | "error" | "skipped";
+type ErrorType = "validation" | "execution" | "timeout" | "cancelled" | "unknown";
+interface WorkflowRun {
+    id: string;
+    workflowKey: string;
+    workflowVersion: string;
+    workflowName?: string;
+    status: RunStatus;
+    startedAt: string;
+    completedAt?: string;
+    duration?: number;
+    triggeredBy?: string;
+    triggerType?: string;
+    error?: WorkflowError;
+    nodeStates?: NodeState[];
+    inputData?: Record<string, unknown>;
+    outputData?: Record<string, unknown>;
+    parentRunId?: string;
+    isSubWorkflowRun?: boolean;
+    subworkflowDepth?: number;
+    rootRunId?: string;
+    childRuns?: WorkflowRun[];
+}
+interface NodeState {
+    id: string;
+    nodeId: string;
+    nodeType: string;
+    nodeName?: string;
+    status: NodeStatus;
+    startedAt?: string;
+    completedAt?: string;
+    duration?: number;
+    inputData?: Record<string, unknown>;
+    outputData?: Record<string, unknown>;
+    error?: string;
+    itemCount?: number;
+    childRunId?: string;
+}
+interface WorkflowError {
+    type: ErrorType;
+    message: string;
+    nodeId?: string;
+    stack?: string;
+}
+interface StepExecutionPlan {
+    runId: string;
+    targetNodeId: string;
+    sourceRunId: string | null;
+    reusedNodeIds: string[];
+    pinnedNodeIds: string[];
+    executeNodeIds: string[];
+    initialNodeIds: string[];
+    blockers: string[];
+}
+interface ExecutionRunMetadata {
+    runId: string;
+    workflowKey: string;
+    version: string;
+    sourceMode?: "TEST" | "PRODUCTION";
+}
+interface ExecutionLog {
+    id: string;
+    runId: string;
+    nodeId: string;
+    nodeType: string;
+    nodeName: string;
+    status: "pending" | "running" | "completed" | "failed";
+    inputArgs: Record<string, unknown> | null;
+    output: Record<string, unknown> | null;
+    error: string | null;
+    duration: number | null;
+    startTime: string;
+    endTime: string | null;
+    usedPinnedData?: boolean;
+    reusedFromRunId?: string | null;
+}
+interface ExecutionsFilter {
+    status?: RunStatus[];
+    workflowKey?: string;
+    dateRange?: {
+        start: string;
+        end: string;
+    };
+    triggeredBy?: string;
+}
+interface ExecutionsPagination {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+declare const RUN_STATUS_CONFIG: Record<RunStatus, {
+    label: string;
+    color: string;
+    bgColor: string;
+}>;
+declare const NODE_STATUS_CONFIG: Record<NodeStatus, {
+    label: string;
+    color: string;
+    bgColor: string;
+}>;
+
+interface WorkflowBuilderCoreProps {
+    workflow?: WorkflowData;
+    readonly?: boolean;
+    hideHeader?: boolean;
+    hideSidebar?: boolean;
+    hideLogsPanel?: boolean;
+    onSave?: (workflow: WorkflowData) => void;
+    onExecute?: (runId: string) => void;
+    onNodeClick?: (node: FlowNode) => void;
+    onBack?: () => void;
+    className?: string;
+}
+declare function WorkflowBuilderCore(props: WorkflowBuilderCoreProps): react_jsx_runtime.JSX.Element;
+
+interface WorkflowBuilderProps extends Omit<WorkflowBuilderCoreProps, "workflow"> {
+    workflowId?: string;
+    workflowVersion?: string;
+    initialWorkflow?: WorkflowData;
+    apiGatewayUrl?: string;
+    globalApiUrl?: string;
+    authToken?: string;
+    workspaceId: string;
+    productId?: string;
+    userId?: string;
+    workspaceToken?: string;
+    tenantId?: string;
+    organizationId?: string;
+    workspaceClient?: ApolloClient;
+    globalClient?: ApolloClient;
+    theme?: FluidGridsProviderProps["theme"];
+    auth?: FluidGridsProviderProps["auth"];
+    onEvent?: FluidGridsProviderProps["onEvent"];
+}
+declare function WorkflowBuilder$1({ workflowId, workflowVersion, initialWorkflow, apiGatewayUrl, globalApiUrl, authToken, workspaceId, tenantId, productId, userId, workspaceToken, organizationId, workspaceClient, globalClient, theme, auth, onEvent, ...coreProps }: WorkflowBuilderProps): react_jsx_runtime.JSX.Element;
+
+declare function WorkflowBuilder(): react_jsx_runtime.JSX.Element;
+
+declare function WorkflowSearchRedirect(): react_jsx_runtime.JSX.Element;
+
+interface ExecutionState {
+    isExecuting: boolean;
+    executingNodeId: string | null;
+    currentRunId: string | null;
+    sourceRun: ExecutionRunMetadata | null;
+    stepPlan: StepExecutionPlan | null;
+    logs: ExecutionLog[];
+    selectedLogId: string | null;
+    panelExpanded: boolean;
+    nodeStatuses: Record<string, "idle" | "running" | "success" | "error">;
+    nodeItemCounts: Record<string, number>;
+    followRequest: {
+        runId: string;
+        triggerNodeId: string;
+    } | null;
+}
+interface CustomEdgeProps extends Edge {
+    condition?: EdgeCondition;
+    mapping?: EdgeMapping;
+}
+interface HistorySnapshot {
+    nodes: Node[];
+    edges: CustomEdgeProps[];
+}
+interface HistoryState {
+    past: HistorySnapshot[];
+    future: HistorySnapshot[];
+}
+interface State {
+    nodes: Node[];
+    edges: CustomEdgeProps[];
+    ndv?: {
+        nodeId: string;
+        type: ExtendedNodeType;
+        tab?: "source";
+    } | null;
+    renamingNodeId?: string | null;
+    quickConfig?: {
+        nodeId: string;
+        type: ExtendedNodeType;
+    } | null;
+    pendingConnection?: {
+        nodeId: string;
+        handleId: string;
+    } | null;
+    sidebar: {
+        active: "node-properties" | "store-browse" | "none";
+        panels: {
+            nodeProperties: {
+                selectedNode: {
+                    id: string;
+                    type: ExtendedNodeType;
+                } | null | undefined;
+            };
+        };
+    };
+}
+interface Actions {
+    actions: {
+        saveWorkflow: () => {
+            id: string;
+            name: string;
+            version: string;
+            alias?: string;
+            dbId?: string;
+            status?: string;
+            nodes: Node[];
+            edges: Edge[];
+        };
+        setWorkflow: (workflow: Partial<IFlowState["workflow"]>) => void;
+        resetWorkflow: () => void;
+        history: {
+            undo: () => void;
+            redo: () => void;
+            clear: () => void;
+        };
+        nodes: {
+            onNodesChange: (changes: NodeChange[]) => void;
+            setNodes: (nodes: Node[], opts?: {
+                historyKind?: string;
+                skipHistory?: boolean;
+            }) => void;
+            deleteNode: (node: Node) => void;
+            deleteNodes: (nodes: Node[]) => void;
+            duplicateNodes: (nodeIds: string[]) => void;
+            pasteNodes: (payload: {
+                nodes: Node[];
+                edges: Edge[];
+            }) => void;
+            toggleDisabled: (nodeId: string) => boolean;
+            renameNode: (nodeId: string, label: string) => void;
+            startRename: (nodeId: string) => void;
+            endRename: () => void;
+        };
+        edges: {
+            onEdgesChange: (changes: EdgeChange[]) => void;
+            onConnect: (connection: Connection) => void;
+            setEdges: (edges: Edge[], opts?: {
+                historyKind?: string;
+                skipHistory?: boolean;
+            }) => void;
+            deleteEdge: (edge: Edge) => void;
+        };
+        ndv: {
+            open: (node: {
+                nodeId: string;
+                type: ExtendedNodeType;
+                tab?: "source";
+            }) => void;
+            close: () => void;
+        };
+        quickConfig: {
+            open: (node: {
+                nodeId: string;
+                type: ExtendedNodeType;
+            }) => void;
+            close: () => void;
+        };
+        pendingConnection: {
+            start: (connection: {
+                nodeId: string;
+                handleId: string;
+            }) => void;
+            clear: () => void;
+        };
+        sidebar: {
+            setActivePanel: (panel: "node-properties" | "store-browse" | "none") => void;
+            showNodePropertiesOf: (node: {
+                id: string;
+                type: ExtendedNodeType;
+                block?: string;
+            }) => void;
+            panels: {
+                nodeProperties: {
+                    setSelectedNode: (node: {
+                        id: string;
+                        type: ExtendedNodeType;
+                    } | undefined | null) => void;
+                };
+                tags: {
+                    setTags: (tags: Tag[]) => void;
+                    createTag: (tag: Tag) => void;
+                    deleteTag: (tag: Tag) => void;
+                    updateTag: (tag: Tag, newTag: Tag) => void;
+                };
+            };
+        };
+    };
+}
+interface IFlowState {
+    tags: Tag[];
+    history: HistoryState;
+    editRevision: number;
+    loadGeneration: number;
+    workflow: {
+        id: string;
+        workflowKey: string;
+        name: string;
+        version: string;
+        alias?: string;
+        dbId?: string;
+        status?: string;
+        codeBuildId?: string;
+        pinnedNodeData?: Record<string, {
+            data: Record<string, unknown>;
+            pinnedAt?: string;
+            pinnedBy?: string;
+        }>;
+    } & State;
+    execution: ExecutionState;
+    actions: Actions["actions"] & {
+        execution: {
+            startExecution: (nodeId: string, runId: string, metadata?: Omit<ExecutionRunMetadata, "runId">) => void;
+            setRunMetadata: (metadata: ExecutionRunMetadata) => void;
+            setStepPlan: (plan: StepExecutionPlan) => void;
+            addLog: (log: ExecutionLog) => void;
+            updateLog: (logId: string, updates: Partial<ExecutionLog>) => void;
+            setNodeStatus: (nodeId: string, status: "idle" | "running" | "success" | "error") => void;
+            setNodeItemCount: (nodeId: string, count: number) => void;
+            selectLog: (logId: string | null) => void;
+            togglePanel: () => void;
+            clearLogs: () => void;
+            completeExecution: () => void;
+            loadDebugRun: (runId: string, logs: ExecutionLog[], metadata?: Omit<ExecutionRunMetadata, "runId">) => void;
+            requestFollowRun: (runId: string, triggerNodeId: string) => void;
+            clearFollowRequest: () => void;
+        };
+    };
+}
+declare const useFlowStore: zustand.UseBoundStore<zustand.StoreApi<IFlowState>>;
+
+declare function refetchStoreNodes(): Promise<void>;
+
+export { type WorkflowError as $, type FluidGridsThemeRadius as A, type FluidGridsThemeTokenKey as B, type ConditionRule as C, type FluidGridsThemeTokenMapping as D, type EdgeCondition as E, FLUIDGRIDS_EVENTS_VERSION as F, type FluidGridsThemeTokens as G, type FluidGridsThemeValueKind as H, type IFlowState as I, type NodeEndpointConfig as J, type NodeManifest as K, type NodeState as L, type MappingValue as M, NODE_STATUS_CONFIG as N, type NodeStatus as O, type RunStatus as P, WorkflowBuilder as Q, RUN_STATUS_CONFIG as R, type SidebarState as S, type Tag as T, WorkflowBuilderCore as U, type WorkflowBuilderCoreProps as V, WorkflowBuilder$1 as W, type WorkflowBuilderProps as X, type WorkflowData as Y, type WorkflowDefinition as Z, type WorkflowDefinitionJson as _, type EdgeMapping as a, type WorkflowRun as a0, type WorkflowSavedResult as a1, WorkflowSearchRedirect as a2, applyFluidGridsTheme as a3, config as a4, getFluidGridsConfig as a5, getGraphQLEndpoint as a6, refetchStoreNodes as a7, resetFluidGridsConfig as a8, resetFluidGridsExecutionState as a9, setFluidGridsConfig as aa, themeToCssVariables as ab, useFlowStore as ac, useFluidGridsContext as ad, type ErrorType as b, type ExecutionLog as c, type ExecutionsFilter as d, type ExecutionsPagination as e, type ExtendedNodeType as f, FLUIDGRIDS_EVENT_NAMES as g, FLUIDGRIDS_THEME_TOKEN_MAP as h, type FlowEdge as i, type FlowNode as j, type FlowNodeData as k, type FluidGridsAuthConfig as l, type FluidGridsConfig as m, type FluidGridsErrorSource as n, type FluidGridsEventArgs as o, type FluidGridsEventHandler as p, type FluidGridsEventMap as q, type FluidGridsEventName as r, type FluidGridsEventPayload as s, FluidGridsProvider as t, type FluidGridsProviderProps as u, type FluidGridsRefreshedTokens as v, type FluidGridsTheme as w, type FluidGridsThemeColors as x, type FluidGridsThemeFont as y, type FluidGridsThemeMode as z };

package/dist/workflow-builder.d.ts

@@ -1,4 +1,4 @@
-export { I as IFlowState, W as WorkflowBuilder, U as WorkflowBuilderCore, V as WorkflowBuilderCoreProps, Q as WorkflowBuilderPage, X as WorkflowBuilderProps, a2 as WorkflowSearchRedirect, a7 as refetchStoreNodes, ac as useFlowStore } from './workflow-builder-C-ekFbwR.js';
+export { I as IFlowState, W as WorkflowBuilder, U as WorkflowBuilderCore, V as WorkflowBuilderCoreProps, Q as WorkflowBuilderPage, X as WorkflowBuilderProps, a2 as WorkflowSearchRedirect, a7 as refetchStoreNodes, ac as useFlowStore } from './workflow-builder-C261exmL.js';
 import 'react/jsx-runtime';
 import '@apollo/client/core';
 import 'react';