@elqnt/workflow 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1159 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { JSONSchema } from '@elqnt/types';
+import React$1 from 'react';
+import * as redux from 'redux';
+
+interface DynamicSchemaFormUIComponents {
+    Input: React.ComponentType<{
+        type?: string;
+        value: any;
+        onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+        disabled?: boolean;
+        className?: string;
+        placeholder?: string;
+        min?: number;
+        max?: number;
+        step?: string | number;
+    }>;
+    Label: React.ComponentType<{
+        htmlFor?: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    Textarea: React.ComponentType<{
+        value: any;
+        onChange: (e: React.ChangeEvent<HTMLTextAreaElement>) => void;
+        disabled?: boolean;
+        rows?: number;
+        className?: string;
+        placeholder?: string;
+    }>;
+    Checkbox: React.ComponentType<{
+        id?: string;
+        checked: boolean;
+        onCheckedChange: (checked: boolean) => void;
+        disabled?: boolean;
+    }>;
+    Select: React.ComponentType<{
+        value: string;
+        onValueChange: (value: string) => void;
+        disabled?: boolean;
+        children: React.ReactNode;
+    }>;
+    SelectTrigger: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    SelectValue: React.ComponentType<{
+        placeholder?: string;
+    }>;
+    SelectContent: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+    SelectItem: React.ComponentType<{
+        value: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    Button: React.ComponentType<{
+        type?: "button" | "submit" | "reset";
+        variant?: string;
+        size?: string;
+        className?: string;
+        onClick?: () => void;
+        disabled?: boolean;
+        children: React.ReactNode;
+    }>;
+    Card: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    PlusIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    TrashIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    ChevronDownIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    ChevronRightIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    VariableIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    CheckIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    EditIcon?: React.ComponentType<{
+        className?: string;
+    }>;
+    Popover?: React.ComponentType<{
+        open?: boolean;
+        onOpenChange?: (open: boolean) => void;
+        children: React.ReactNode;
+    }>;
+    PopoverTrigger?: React.ComponentType<{
+        asChild?: boolean;
+        children: React.ReactNode;
+    }>;
+    PopoverContent?: React.ComponentType<{
+        className?: string;
+        align?: "start" | "center" | "end";
+        children: React.ReactNode;
+    }>;
+    Dialog?: React.ComponentType<{
+        open?: boolean;
+        onOpenChange?: (open: boolean) => void;
+        children: React.ReactNode;
+    }>;
+    DialogContent?: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    DialogHeader?: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    DialogTitle?: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    DialogFooter?: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    ScrollArea?: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    MarkdownEditor?: React.ComponentType<{
+        content: string;
+        onChange: (markdown: string) => void;
+        placeholder?: string;
+        className?: string;
+        readOnly?: boolean;
+        minHeight?: string;
+        variables?: Array<{
+            name: string;
+            path: string;
+            title?: string;
+        }>;
+    }>;
+    cn: (...classes: (string | undefined | null | false)[]) => string;
+}
+/**
+ * Variable definition for workflow variables
+ */
+interface WorkflowVariable {
+    name: string;
+    type: string;
+    title?: string;
+    path: string;
+}
+interface DynamicSchemaFormProps {
+    schema: JSONSchema;
+    value: any;
+    onChange: (value: any) => void;
+    disabled?: boolean;
+    path?: string[];
+    components: DynamicSchemaFormUIComponents;
+    /** Workflow variables available for selection */
+    variables?: WorkflowVariable[];
+    /** Whether to show variable picker buttons */
+    showVariablePicker?: boolean;
+}
+declare function DynamicSchemaForm({ schema, value, onChange, disabled, path, components, variables, showVariablePicker, }: DynamicSchemaFormProps): react_jsx_runtime.JSX.Element;
+
+interface SchemaBuilderUIComponents {
+    Input: React.ComponentType<{
+        value: any;
+        onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+        disabled?: boolean;
+        className?: string;
+        placeholder?: string;
+    }>;
+    Label: React.ComponentType<{
+        htmlFor?: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    Checkbox: React.ComponentType<{
+        id?: string;
+        checked: boolean;
+        onCheckedChange: (checked: boolean) => void;
+        disabled?: boolean;
+    }>;
+    Select: React.ComponentType<{
+        value: string;
+        onValueChange: (value: string) => void;
+        disabled?: boolean;
+        children: React.ReactNode;
+    }>;
+    SelectTrigger: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    SelectValue: React.ComponentType<{
+        placeholder?: string;
+    }>;
+    SelectContent: React.ComponentType<{
+        children: React.ReactNode;
+    }>;
+    SelectItem: React.ComponentType<{
+        value: string;
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    Button: React.ComponentType<{
+        type?: "button" | "submit" | "reset";
+        variant?: string;
+        size?: string;
+        className?: string;
+        onClick?: () => void;
+        disabled?: boolean;
+        children: React.ReactNode;
+    }>;
+    Card: React.ComponentType<{
+        className?: string;
+        children: React.ReactNode;
+    }>;
+    PlusIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    TrashIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    GripVerticalIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    ChevronDownIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    ChevronRightIcon: React.ComponentType<{
+        className?: string;
+    }>;
+    cn: (...classes: (string | undefined | null | false)[]) => string;
+}
+interface SchemaBuilderProps {
+    schema: JSONSchema;
+    onChange: (schema: JSONSchema) => void;
+    disabled?: boolean;
+    components: SchemaBuilderUIComponents;
+}
+declare function SchemaBuilder({ schema, onChange, disabled, components, }: SchemaBuilderProps): react_jsx_runtime.JSX.Element;
+
+type NodeSubTypeTS = "actionAIClassify" | "actionAIExtractData" | "actionAISummarize" | "actionApiCall" | "actionAssignSLAPolicy" | "actionCreateEntityRecord" | "actionDeleteEntityRecord" | "actionDocumentExtraction" | "actionNatsRequest" | "actionQueryEntityRecords" | "actionSendEmail" | "actionSendSMS" | "actionSetVariables" | "actionUpdateEntityRecord" | "agentChat" | "agentCustomResponse" | "agentIntentDetector" | "agentKnowledgeGraph" | "agentOpenTicket" | "agentStructuredOutput" | "agentTransferToHuman" | "delay" | "humanActionApproval" | "humanActionAssignment" | "humanActionDataEntry" | "humanActionReview" | "integrationCreateEvent" | "integrationGetDriveFile" | "integrationSearchCalendar" | "integrationSearchDrive" | "integrationSearchEmails" | "integrationSendEmail" | "logicFor" | "logicIf" | "logicSwitch" | "triggerCalendarEvent" | "triggerDriveFileChanged" | "triggerEmailReceived" | "triggerEntityRecordCreated" | "triggerEntityRecordDeleted" | "triggerEntityRecordUpdated" | "triggerEscalation" | "triggerSLABreach" | "triggerSLAWarning" | "triggerSchedule" | "triggerStart" | "triggerWebhookReceived";
+interface NodeSubTypeInfo {
+    value: string;
+    label: string;
+    icon: string;
+    description: string;
+}
+declare const nodeDefinitions: Record<string, NodeDefinition>;
+declare const nodeSchemas: Record<string, JSONSchema>;
+declare const TriggerNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const HumanActionNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const AgentNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const ActionNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const LogicNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const DelayNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const ParallelNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const DataNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const TimerNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const LoopNodeSubTypes: Record<string, NodeSubTypeInfo>;
+declare const AccountingNodeSubTypes: Record<string, NodeSubTypeInfo>;
+type TriggerNodeSubType = keyof typeof TriggerNodeSubTypes;
+type HumanActionNodeSubType = keyof typeof HumanActionNodeSubTypes;
+type AgentNodeSubType = keyof typeof AgentNodeSubTypes;
+type ActionNodeSubType = keyof typeof ActionNodeSubTypes;
+type LogicNodeSubType = keyof typeof LogicNodeSubTypes;
+type DelayNodeSubType = keyof typeof DelayNodeSubTypes;
+type DataNodeSubType = keyof typeof DataNodeSubTypes;
+type TimerNodeSubType = keyof typeof TimerNodeSubTypes;
+type LoopNodeSubType = keyof typeof LoopNodeSubTypes;
+type ParallelNodeSubType = keyof typeof ParallelNodeSubTypes;
+type AccountingNodeSubType = keyof typeof AccountingNodeSubTypes;
+type WorkflowNodeSubTypeTS = TriggerNodeSubType | HumanActionNodeSubType | AgentNodeSubType | ActionNodeSubType | LogicNodeSubType | DelayNodeSubType | DataNodeSubType | TimerNodeSubType | LoopNodeSubType | ParallelNodeSubType | AccountingNodeSubType;
+declare const WorkflowNodeTypes: {
+    readonly trigger: {
+        readonly value: "trigger";
+        readonly label: "Trigger";
+        readonly category: "Triggers";
+    };
+    readonly humanAction: {
+        readonly value: "humanAction";
+        readonly label: "Human Action";
+        readonly category: "User Interaction";
+    };
+    readonly agent: {
+        readonly value: "agent";
+        readonly label: "Agent";
+        readonly category: "Automation";
+    };
+    readonly action: {
+        readonly value: "action";
+        readonly label: "Action";
+        readonly category: "Automation";
+    };
+    readonly logic: {
+        readonly value: "logic";
+        readonly label: "Logic";
+        readonly category: "Flow Control";
+    };
+    readonly data: {
+        readonly value: "data";
+        readonly label: "Data";
+        readonly category: "Data Processing";
+    };
+    readonly integration: {
+        readonly value: "integration";
+        readonly label: "Integration";
+        readonly category: "Integration";
+    };
+    readonly timer: {
+        readonly value: "timer";
+        readonly label: "Timer";
+        readonly category: "Time & Scheduling";
+    };
+    readonly loop: {
+        readonly value: "loop";
+        readonly label: "Loop";
+        readonly category: "Flow Control";
+    };
+    readonly parallel: {
+        readonly value: "parallel";
+        readonly label: "Parallel";
+        readonly category: "Flow Control";
+    };
+    readonly delay: {
+        readonly value: "delay";
+        readonly label: "Delay";
+        readonly category: "Flow Control";
+    };
+    readonly subflow: {
+        readonly value: "subflow";
+        readonly label: "Subflow";
+        readonly category: "Flow Control";
+    };
+    readonly custom: {
+        readonly value: "custom";
+        readonly label: "Custom";
+        readonly category: "Custom";
+    };
+    readonly documentExtraction: {
+        readonly value: "documentExtraction";
+        readonly label: "Document Extraction";
+        readonly category: "Data Processing";
+    };
+    readonly apiCall: {
+        readonly value: "apiCall";
+        readonly label: "API Call";
+        readonly category: "Integration";
+    };
+    readonly accounting: {
+        readonly value: "accounting";
+        readonly label: "Accounting";
+        readonly category: "Accounting";
+    };
+};
+type WorkflowNodeTypeTS = keyof typeof WorkflowNodeTypes;
+type WorkflowNodeTypeOptionTS = typeof WorkflowNodeTypes[WorkflowNodeTypeTS];
+type NodeCategory = "Triggers" | "User Interaction" | "Automation" | "Integration" | "Flow Control" | "Data Processing" | "Time & Scheduling" | "Custom" | "Document Processing" | "API Integration" | "Accounting";
+declare const WorkflowEdgeTypes: Record<string, EdgeTypeDefinition>;
+type WorkflowEdgeTypeTS = keyof typeof WorkflowEdgeTypes;
+type WorkflowEdgeTypeOptionTS = typeof WorkflowEdgeTypes[WorkflowEdgeTypeTS];
+declare const WorkflowTypes: Record<string, WorkflowTypeDefinition>;
+type WorkflowTypeTS = keyof typeof WorkflowTypes;
+type WorkflowTypeOptionTS = typeof WorkflowTypes[WorkflowTypeTS];
+
+/**
+ * NodeType represents the primary type of a workflow node
+ */
+type NodeType = string;
+declare const NodeTypeTrigger: NodeType;
+declare const NodeTypeHumanAction: NodeType;
+declare const NodeTypeAgent: NodeType;
+declare const NodeTypeAction: NodeType;
+declare const NodeTypeLogic: NodeType;
+declare const NodeTypeLoop: NodeType;
+declare const NodeTypeParallel: NodeType;
+declare const NodeTypeDelay: NodeType;
+declare const NodeTypeData: NodeType;
+declare const NodeTypeIntegration: NodeType;
+declare const NodeTypeTimer: NodeType;
+declare const NodeTypeSubflow: NodeType;
+declare const NodeTypeCustom: NodeType;
+declare const NodeTypeAccounting: NodeType;
+/**
+ * NodeSubType represents the subtype of a workflow node
+ * All node subtypes are unified under this single type
+ */
+type NodeSubType = string;
+/**
+ * Trigger subtypes
+ */
+declare const NodeSubTypeTriggerStart: NodeSubType;
+declare const NodeSubTypeTriggerEntityRecordCreated: NodeSubType;
+declare const NodeSubTypeTriggerEntityRecordUpdated: NodeSubType;
+declare const NodeSubTypeTriggerEntityRecordDeleted: NodeSubType;
+declare const NodeSubTypeTriggerSLAWarning: NodeSubType;
+declare const NodeSubTypeTriggerSLABreach: NodeSubType;
+declare const NodeSubTypeTriggerEscalation: NodeSubType;
+declare const NodeSubTypeTriggerWebhookReceived: NodeSubType;
+/**
+ * Human action subtypes
+ */
+declare const NodeSubTypeHumanActionReview: NodeSubType;
+declare const NodeSubTypeHumanActionApproval: NodeSubType;
+declare const NodeSubTypeHumanActionDataEntry: NodeSubType;
+declare const NodeSubTypeHumanActionAssignment: NodeSubType;
+/**
+ * Agent subtypes
+ */
+declare const NodeSubTypeAgentChat: NodeSubType;
+declare const NodeSubTypeAgentIntentDetector: NodeSubType;
+declare const NodeSubTypeAgentKnowledgeGraph: NodeSubType;
+declare const NodeSubTypeAgentClientApiCall: NodeSubType;
+declare const NodeSubTypeAgentTransferToHuman: NodeSubType;
+declare const NodeSubTypeAgentOpenTicket: NodeSubType;
+declare const NodeSubTypeAgentApiIntegration: NodeSubType;
+declare const NodeSubTypeAgentCustomResponse: NodeSubType;
+declare const NodeSubTypeAgentStructuredOutput: NodeSubType;
+/**
+ * Action subtypes
+ */
+declare const NodeSubTypeActionApiCall: NodeSubType;
+declare const NodeSubTypeActionDocumentExtraction: NodeSubType;
+declare const NodeSubTypeActionSendEmail: NodeSubType;
+declare const NodeSubTypeActionSendSMS: NodeSubType;
+declare const NodeSubTypeActionGenerateDocument: NodeSubType;
+declare const NodeSubTypeActionProcessPayment: NodeSubType;
+declare const NodeSubTypeActionCreateEntityRecord: NodeSubType;
+declare const NodeSubTypeActionUpdateEntityRecord: NodeSubType;
+declare const NodeSubTypeActionDeleteEntityRecord: NodeSubType;
+declare const NodeSubTypeActionMergeEntityRecords: NodeSubType;
+declare const NodeSubTypeActionAssignSLAPolicy: NodeSubType;
+declare const NodeSubTypeActionChangeSLAStatus: NodeSubType;
+declare const NodeSubTypeActionEscalateSLA: NodeSubType;
+declare const NodeSubTypeActionCSATSurvey: NodeSubType;
+declare const NodeSubTypeActionSetVariables: NodeSubType;
+declare const NodeSubTypeActionQueryEntityRecords: NodeSubType;
+declare const NodeSubTypeActionNatsRequest: NodeSubType;
+/**
+ * Logic subtypes
+ */
+declare const NodeSubTypeLogicIf: NodeSubType;
+declare const NodeSubTypeLogicSwitch: NodeSubType;
+declare const NodeSubTypeLogicFor: NodeSubType;
+declare const NodeSubTypeLogicParallel: NodeSubType;
+/**
+ * Loop subtypes
+ */
+declare const NodeSubTypeLoopData: NodeSubType;
+/**
+ * Delay subtypes
+ */
+declare const NodeSubTypeDelay: NodeSubType;
+/**
+ * Data subtypes
+ */
+declare const NodeSubTypeDataFilter: NodeSubType;
+declare const NodeSubTypeDataMap: NodeSubType;
+declare const NodeSubTypeDataCalculate: NodeSubType;
+declare const NodeSubTypeDataValidate: NodeSubType;
+/**
+ * Timer subtypes
+ */
+declare const NodeSubTypeTimerDelay: NodeSubType;
+declare const NodeSubTypeTimerSchedule: NodeSubType;
+declare const NodeSubTypeTimerBusinessHours: NodeSubType;
+/**
+ * ExpressionType defines the type of expression evaluation to be used
+ */
+type ExpressionType = string;
+/**
+ * Simple filter-based expressions using predefined operators
+ */
+declare const ExpressionTypeFilter: ExpressionType;
+/**
+ * JavaScript-like expressions with full language features
+ */
+declare const ExpressionTypeJavaScript: ExpressionType;
+/**
+ * Template expressions with variable interpolation
+ */
+declare const ExpressionTypeTemplate: ExpressionType;
+/**
+ * Custom domain-specific language expressions
+ */
+declare const ExpressionTypeDSL: ExpressionType;
+/**
+ * Complex rule-based expressions (e.g., business rules)
+ */
+declare const ExpressionTypeRules: ExpressionType;
+/**
+ * EdgeType defines the type and behavior of workflow edges
+ */
+type EdgeType = string;
+/**
+ * Standard flow between nodes
+ */
+declare const EdgeTypeNormal: EdgeType;
+/**
+ * Loop back to previous node
+ */
+declare const EdgeTypeLoopBack: EdgeType;
+/**
+ * Error handling path
+ */
+declare const EdgeTypeError: EdgeType;
+/**
+ * Fallback/default path when no other conditions match
+ */
+declare const EdgeTypeDefault: EdgeType;
+/**
+ * Path for parallel execution branch
+ */
+declare const EdgeTypeParallel: EdgeType;
+/**
+ * Path for conditional branching
+ */
+declare const EdgeTypeConditional: EdgeType;
+/**
+ * Path for merging parallel branches
+ */
+declare const EdgeTypeMerge: EdgeType;
+/**
+ * Compensating/rollback path
+ */
+declare const EdgeTypeCompensation: EdgeType;
+/**
+ * Path for timeout/deadline handling
+ */
+declare const EdgeTypeTimeout: EdgeType;
+type WorkflowType = string;
+declare const WorkflowTypeEntity: WorkflowType;
+declare const WorkflowTypeDocument: WorkflowType;
+declare const WorkflowTypeChat: WorkflowType;
+declare const WorkflowTypeAgent: WorkflowType;
+declare const WorkflowTypeProductivity: WorkflowType;
+/**
+ * NodeDefinition is the design-time template for creating WorkflowNode instances.
+ * This is the single source of truth for all node types in the workflow system.
+ * Generated to TypeScript via schema-generator for use in the workflow designer UI.
+ */
+interface NodeDefinition {
+    type: NodeType;
+    subType: NodeSubTypeTS;
+    label: string;
+    icon: string;
+    description: string;
+    category: string;
+    config: JSONSchema;
+    input: JSONSchema;
+    output: JSONSchema;
+}
+/**
+ * EdgeTypeDefinition defines metadata for an edge type
+ */
+interface EdgeTypeDefinition {
+    value: string;
+    label: string;
+}
+/**
+ * WorkflowTypeDefinition defines metadata for a workflow type
+ */
+interface WorkflowTypeDefinition {
+    value: string;
+    label: string;
+}
+interface LogicPath {
+    id: string;
+    nodeId: string;
+    condition: string;
+    priority: number;
+}
+interface Intent {
+    id: string;
+    nodeId: string;
+    name: string;
+    description: string;
+}
+interface ResponseMetadata {
+    success: boolean;
+    timestamp: string;
+    message?: string;
+    error?: string;
+}
+interface Metadata {
+    createdBy: string;
+    createdAt: string;
+    updatedBy?: string;
+    updatedAt?: string;
+    isActive: boolean;
+    version: number;
+}
+interface CreateWorkflowDefinitionRequest {
+    definition: WorkflowDefinition;
+    orgId: string;
+}
+interface UpdateWorkflowDefinitionRequest {
+    definition: WorkflowDefinition;
+    orgId: string;
+}
+interface WorkflowDefinitionResponse {
+    definition: WorkflowDefinition;
+    metadata: ResponseMetadata;
+}
+interface GetWorkflowDefinitionRequest {
+    id: string;
+    orgId: string;
+}
+interface GetWorkflowDefinitionByTitleRequest {
+    title: string;
+    orgId: string;
+}
+interface ListWorkflowDefinitionsRequest {
+    orgId: string;
+    status?: string;
+}
+interface ListWorkflowDefinitionsResponse {
+    definitions: WorkflowDefinition[];
+    metadata: ResponseMetadata;
+}
+interface DeleteWorkflowDefinitionRequest {
+    id: string;
+    orgId: string;
+}
+/**
+ * Workflow Definition models
+ */
+interface WorkflowDefinition {
+    /**
+     * Core Identity
+     */
+    id?: string;
+    title: string;
+    description: string;
+    type: WorkflowTypeTS;
+    /**
+     * Graph Structure
+     */
+    nodes: {
+        [key: string]: WorkflowNode;
+    };
+    edges: WorkflowEdge[];
+    entryPoints: string[];
+    /**
+     * Data Management
+     */
+    variables: WorkflowVariables;
+    constants?: {
+        [key: string]: any;
+    };
+    /**
+     * Runtime Configuration
+     */
+    persistence?: PersistenceType;
+    /**
+     * Validation and Constraints
+     */
+    rules?: WorkflowRule[];
+    permissions: WorkflowPermissions;
+    /**
+     * Metadata and Tracking
+     */
+    metadata: WorkflowMetadata;
+}
+interface WorkflowVariables {
+    schema: JSONSchema;
+    scope: {
+        [key: string]: string;
+    };
+    defaultValues: {
+        [key: string]: any;
+    };
+    computed: {
+        [key: string]: string;
+    };
+}
+interface WorkflowRule {
+    name: string;
+    description: string;
+    condition: string;
+    action: string;
+    level: RuleLevel;
+}
+type RuleLevel = string;
+declare const RuleLevelError: RuleLevel;
+declare const RuleLevelWarning: RuleLevel;
+declare const RuleLevelInfo: RuleLevel;
+interface WorkflowPermissions {
+    roles: {
+        [key: string]: string[];
+    };
+    accessLevel: string;
+    editableBy: string[];
+    viewableBy: string[];
+}
+interface WorkflowMetadata {
+    createdBy: string;
+    createdAt: string;
+    updatedBy?: string;
+    updatedAt?: string;
+    isActive: boolean;
+    version: number;
+    tags?: string[];
+    category?: string;
+    labels?: string[];
+}
+type PersistenceType = string;
+declare const PersistenceTypeEphemeral: PersistenceType;
+declare const PersistenceTypePermanent: PersistenceType;
+/**
+ * todo: validate default values against schema
+ */
+interface NodeInput {
+    schema: JSONSchema;
+    defaultValues?: {
+        [key: string]: any;
+    };
+}
+interface NodeOutput {
+    schema: JSONSchema;
+    /**
+     * Mapping map[string]string `json:"mapping,omitempty"`
+     */
+    values?: {
+        [key: string]: any;
+    };
+}
+interface NodeConfig {
+    schema: JSONSchema;
+    values: {
+        [key: string]: any;
+    };
+    promoteToVariables?: string[];
+}
+interface WorkflowNode {
+    id: string;
+    title: string;
+    name: string;
+    label?: string;
+    description?: string;
+    type: WorkflowNodeTypeTS;
+    subType?: WorkflowNodeSubTypeTS;
+    config: NodeConfig;
+    settings: NodeSettings;
+    input: NodeInput;
+    output: NodeOutput;
+    isStart: boolean;
+}
+/**
+ * NodeSettings contains type-specific configuration
+ */
+interface NodeSettings {
+    /**
+     * Shared configs
+     */
+    execution?: ExecutionConfig;
+    retry?: RetryConfig;
+}
+interface ExecutionConfig {
+    timeoutSeconds: number;
+    priority: number;
+    subject?: string;
+}
+interface RetryConfig {
+    maxAttempts: number;
+    initialDelay: any;
+    maxDelay: any;
+    backoffMultiplier: number;
+}
+/**
+ * CacheConfig defines caching behavior for expression results
+ */
+interface CacheConfig {
+    enabled: boolean;
+    ttl: any;
+    key?: string;
+    tags?: string[];
+}
+interface ExpressionConfig {
+    type: ExpressionType;
+    expression: string;
+    variables?: string[];
+    timeout?: any;
+    cache?: CacheConfig;
+}
+/**
+ * Example usage in full edge structure
+ */
+interface WorkflowEdge {
+    id: string;
+    fromNodeId: string;
+    toNodeId: string;
+    type: WorkflowEdgeTypeTS;
+    label?: string;
+    expression?: ExpressionConfig;
+    priority: number;
+    retry?: RetryConfig;
+    timeout?: TimeoutConfig;
+    properties?: {
+        [key: string]: string;
+    };
+}
+/**
+ * TimeoutConfig defines timeout behavior for nodes and edges
+ */
+interface TimeoutConfig {
+    duration: any;
+    action: TimeoutAction;
+    retryPolicy?: RetryConfig;
+}
+type TimeoutAction = string;
+declare const TimeoutActionFail: TimeoutAction;
+declare const TimeoutActionSkip: TimeoutAction;
+declare const TimeoutActionRetry: TimeoutAction;
+declare const TimeoutActionAlt: TimeoutAction;
+interface CreateWorkflowInstanceRequest {
+    orgId: string;
+    definitionId: string;
+    variables: {
+        [key: string]: any;
+    };
+    autoExecute: boolean;
+}
+interface WorkflowInstanceResponse {
+    instance?: WorkflowInstance;
+    metadata: ResponseMetadata;
+}
+interface WorkflowInstanceExecuteNodeRequest {
+    orgId: string;
+    instanceId: string;
+    nodeId: string;
+    input: {
+        [key: string]: any;
+    };
+}
+interface WorkflowInstanceResumeNodeRequest {
+    orgId: string;
+    instanceId: string;
+    nodeId: string;
+    result: {
+        [key: string]: any;
+    };
+}
+interface WorkflowInstanceExecuteNodeLeanRequest {
+    orgId: string;
+    nodeDef: WorkflowNode;
+    input: {
+        [key: string]: any;
+    };
+}
+interface UpdateInstanceNodeMetadataRequest {
+    orgId: string;
+    instanceId: string;
+    nodeId: string;
+    metadataKey: string;
+    payload: any;
+}
+interface GetWorkflowInstanceRequest {
+    orgId: string;
+    instanceId: string;
+}
+interface ListWorkflowInstancesRequest {
+    orgId: string;
+    definitionId: string;
+}
+interface ListWorkflowInstancesResponse {
+    instances: WorkflowInstance[];
+    metadata: ResponseMetadata;
+}
+interface UpdateInstanceStatusRequest {
+    orgId: string;
+    instanceId: string;
+    status: InstanceStatus;
+}
+interface RetryNodeRequest {
+    orgId: string;
+    instanceId: string;
+    nodeId: string;
+}
+interface ListInstancesOptions {
+    definitionId: string;
+    status: InstanceStatus;
+    limit: number;
+    offset: number;
+}
+interface InstanceState {
+    variables: {
+        [key: string]: any;
+    };
+    constants: {
+        [key: string]: any;
+    };
+    nodeStates: {
+        [key: string]: NodeState;
+    };
+    edgeStates: {
+        [key: string]: EdgeState;
+    };
+}
+interface ExecutionContext {
+    currentNodes: string[];
+    path: ExecutionPathEntry[];
+    errors: ExecutionError[];
+}
+/**
+ * Workflow Instance models
+ */
+interface WorkflowInstance {
+    id?: string;
+    orgId?: string;
+    definitionId: string;
+    title?: string;
+    description?: string;
+    type?: WorkflowType;
+    definitionVersion: number;
+    status: InstanceStatus;
+    state: InstanceState;
+    context: ExecutionContext;
+    persistence?: PersistenceType;
+    metadata: WorkflowMetadata;
+}
+interface NodeState {
+    status: NodeStatus;
+    input?: {
+        [key: string]: any;
+    };
+    output?: {
+        [key: string]: any;
+    };
+    /**
+     * Variables   map[string]interface{} `json:"variables,omitempty"`
+     */
+    error?: string;
+    startTime?: string;
+    endTime?: string;
+    retryCount: number;
+    nextRetryAt?: string;
+}
+interface EdgeState {
+    status: EdgeStatus;
+    timestamp: string;
+    error?: string;
+}
+interface ExecutionPathEntry {
+    nodeId: string;
+    edgeId: string;
+    type: string;
+    timestamp: string;
+    data?: {
+        [key: string]: any;
+    };
+}
+interface ExecutionError {
+    nodeId?: string;
+    edgeId?: string;
+    error: string;
+    timestamp: string;
+    retryable: boolean;
+}
+type InstanceStatus = string;
+declare const InstanceStatusNew: InstanceStatus;
+declare const InstanceStatusRunning: InstanceStatus;
+declare const InstanceStatusWaiting: InstanceStatus;
+declare const InstanceStatusPaused: InstanceStatus;
+declare const InstanceStatusCompleted: InstanceStatus;
+declare const InstanceStatusFailed: InstanceStatus;
+interface NodeInstance {
+    nodeId: string;
+    status: NodeStatus;
+    input?: {
+        [key: string]: any;
+    };
+    output?: {
+        [key: string]: any;
+    };
+    error?: string;
+    startTime?: string;
+    endTime?: string;
+    retryCount: number;
+    nextRetryAt?: string;
+}
+type NodeStatus = string;
+declare const NodeStatusPending: NodeStatus;
+declare const NodeStatusRunning: NodeStatus;
+declare const NodeStatusCompleted: NodeStatus;
+declare const NodeStatusFailed: NodeStatus;
+declare const NodeStatusWaiting: NodeStatus;
+declare const NodeStatusSkipped: NodeStatus;
+type EdgeStatus = string;
+declare const EdgeStatusPending: EdgeStatus;
+declare const EdgeStatusCompleted: EdgeStatus;
+declare const EdgeStatusSkipped: EdgeStatus;
+/**
+ * WorkflowDefinitionInfo holds summarized info about an active workflow definition
+ * Used by schedulers and services that need to process workflows without full definition details
+ */
+interface WorkflowDefinitionInfo {
+    id: string;
+    orgId: string;
+    title: string;
+    type: string;
+    category: string;
+    isActive: boolean;
+    createdBy: string;
+    /**
+     * User config from definition.variables.defaultValues (workflow-specific)
+     */
+    provider?: string;
+    userEmail?: string;
+    userId?: string;
+}
+
+declare const WorkflowDefinitionCreate = "workflow.definition.create";
+declare const WorkflowDefinitionCreated = "workflow.definition.created";
+declare const WorkflowDefinitionUpdate = "workflow.definition.update";
+declare const WorkflowDefinitionUpdated = "workflow.definition.updated";
+declare const WorkflowDefinitionGet = "workflow.definition.get";
+declare const WorkflowDefinitionGetServer = "workflow.definition.get.server";
+declare const WorkflowDefinitionGetByTitle = "workflow.definition.get.by.title";
+declare const WorkflowDefinitionList = "workflow.definition.list";
+declare const WorkflowDefinitionDelete = "workflow.definition.delete";
+declare const WorkflowDefinitionDeleted = "workflow.definition.deleted";
+declare const WorkflowInstanceCreate = "workflow.instance.create";
+declare const WorkflowInstanceExecuteNode = "workflow.instance.execute.node";
+declare const WorkflowInstanceResumeNode = "workflow.instance.resume.node";
+declare const WorkflowInstanceExecuteNodeServer = "workflow.instance.execute.node.server";
+declare const WorkflowInstanceResumeNodeServer = "workflow.instance.resume.node.server";
+declare const WorkflowInstanceExecuteNodeLean = "workflow.instance.execute.node.lean";
+declare const WorkflowInstanceExecuteNodeLeanServer = "workflow.instance.execute.node.lean.server";
+declare const WorkflowInstanceGet = "workflow.instance.get";
+declare const WorkflowInstanceList = "workflow.instance.list";
+declare const WorkflowInstanceUpdate = "workflow.instance.update";
+declare const WorkflowInstanceUpdated = "workflow.instance.updated";
+declare const WorkflowInstanceUpdateNodeMetadata = "workflow.instance.update.node.metadata";
+/**
+ * Template management
+ */
+declare const WorkflowTemplateList = "workflow.template.list";
+declare const WorkflowTemplateGet = "workflow.template.get";
+declare const WorkflowTemplateInstantiate = "workflow.template.instantiate";
+/**
+ * Schedule management
+ */
+declare const WorkflowScheduleCreate = "workflow.schedule.create";
+declare const WorkflowScheduleUpdate = "workflow.schedule.update";
+declare const WorkflowScheduleDelete = "workflow.schedule.delete";
+declare const WorkflowScheduleList = "workflow.schedule.list";
+declare const WorkflowSchedulePause = "workflow.schedule.pause";
+declare const WorkflowScheduleResume = "workflow.schedule.resume";
+/**
+ * Trigger management
+ */
+declare const WorkflowTriggerRegister = "workflow.trigger.register";
+declare const WorkflowTriggerPause = "workflow.trigger.pause";
+declare const WorkflowTriggerResume = "workflow.trigger.resume";
+declare const WorkflowTriggerStatus = "workflow.trigger.status";
+declare const WorkflowTriggerFired = "workflow.trigger.fired";
+/**
+ * Execution events
+ */
+declare const WorkflowExecutionStarted = "workflow.execution.started";
+declare const WorkflowExecutionCompleted = "workflow.execution.completed";
+declare const WorkflowExecutionFailed = "workflow.execution.failed";
+
+type UseWorkflowDefinitionType = {
+    definitions: Record<string, WorkflowDefinition>;
+    selectedDefinition?: WorkflowDefinition;
+    isLoading: boolean;
+    loadingStates: Record<string, boolean>;
+    error?: string;
+    loadDefinitions: () => Promise<void>;
+    loadDefinition: (id: string) => Promise<void>;
+    resetSelectedDefinition: () => void;
+    createDefinition: (definition: WorkflowDefinition) => Promise<WorkflowDefinitionResponse>;
+    updateDefinition: (id: string, definition: WorkflowDefinition) => Promise<WorkflowDefinitionResponse>;
+    deleteDefinition: (id: string) => Promise<ResponseMetadata>;
+    refresh: () => void;
+};
+interface UseWorkflowDefinitionOptions {
+    autoLoad?: boolean;
+}
+declare function useWorkflowDefinition(orgId: string | undefined, definitionId?: string, options?: UseWorkflowDefinitionOptions): UseWorkflowDefinitionType;
+
+type UseWorkflowInstanceType = {
+    instances: Record<string, WorkflowInstance>;
+    selectedInstance?: WorkflowInstance;
+    doSetSelectedInstance: (instance: WorkflowInstance | undefined) => void;
+    isLoading: boolean;
+    loadingStates: Record<string, boolean>;
+    error?: string;
+    loadInstances: (definitionId: string) => Promise<void>;
+    loadInstance: (id: string) => Promise<void>;
+    getInstance: (id: string) => Promise<WorkflowInstanceResponse>;
+    createInstance: (definitionId: string, variables?: {
+        [key: string]: any;
+    }) => Promise<WorkflowInstanceResponse>;
+    executeNode: (instanceId: string, nodeId: string, input?: any) => Promise<WorkflowInstanceResponse>;
+    updateInstanceNodeMetadata: (instanceId: string, nodeId: string, metadataKey: string, payload: any) => Promise<WorkflowInstanceResponse>;
+    resumeInstanceNode: (instanceId: string, nodeId: string, result: {
+        [key: string]: any;
+    }) => Promise<WorkflowInstanceResponse>;
+    refresh: () => void;
+};
+interface UseWorkflowInstanceOptions {
+    autoLoad?: boolean;
+}
+declare function useWorkflowInstance(orgId: string | undefined, instanceId?: string, definitionId?: string, options?: UseWorkflowInstanceOptions): UseWorkflowInstanceType;
+
+declare const WorkflowDefinitionContext: React$1.Context<UseWorkflowDefinitionType | undefined>;
+interface WorkflowDefinitionProviderProps {
+    children: React$1.ReactNode;
+    orgId?: string;
+    definitionId?: string;
+    options?: UseWorkflowDefinitionOptions;
+}
+declare function WorkflowDefinitionProvider({ children, orgId, definitionId, options, }: WorkflowDefinitionProviderProps): react_jsx_runtime.JSX.Element;
+declare function useWorkflowDefinitionContext(): UseWorkflowDefinitionType;
+
+declare const WorkflowInstanceContext: React$1.Context<UseWorkflowInstanceType | undefined>;
+interface WorkflowInstanceProviderProps {
+    children: React$1.ReactNode;
+    orgId: string;
+    instanceId?: string;
+    definitionId?: string;
+    options?: UseWorkflowInstanceOptions;
+}
+declare function WorkflowInstanceProvider({ children, orgId, instanceId, definitionId, options, }: WorkflowInstanceProviderProps): react_jsx_runtime.JSX.Element;
+declare function useWorkflowInstanceContext(): UseWorkflowInstanceType;
+
+interface WorkflowDefinitionState {
+    definitions: Record<string, WorkflowDefinition>;
+    selectedDefinition?: WorkflowDefinition;
+    isLoading: boolean;
+    error?: string;
+    loadingStates: Record<string, boolean>;
+}
+interface WorkflowDefinitionSelector {
+    workflowDefinition: WorkflowDefinitionState;
+}
+declare const workflowDefinitionReducer: redux.Reducer<WorkflowDefinitionState>;
+
+interface WorkflowInstanceState {
+    instances: Record<string, WorkflowInstance>;
+    selectedInstance?: WorkflowInstance;
+    isLoading: boolean;
+    error?: string;
+    loadingStates: Record<string, boolean>;
+}
+interface WorkflowInstanceSelector {
+    workflowInstance: WorkflowInstanceState;
+}
+declare const workflowInstanceReducer: redux.Reducer<WorkflowInstanceState>;
+
+export { type AccountingNodeSubType, AccountingNodeSubTypes, type ActionNodeSubType, ActionNodeSubTypes, type AgentNodeSubType, AgentNodeSubTypes, type CacheConfig, type CreateWorkflowDefinitionRequest, type CreateWorkflowInstanceRequest, type DataNodeSubType, DataNodeSubTypes, type DelayNodeSubType, DelayNodeSubTypes, type DeleteWorkflowDefinitionRequest, DynamicSchemaForm, type DynamicSchemaFormProps, type DynamicSchemaFormUIComponents, type EdgeState, type EdgeStatus, EdgeStatusCompleted, EdgeStatusPending, EdgeStatusSkipped, type EdgeType, EdgeTypeCompensation, EdgeTypeConditional, EdgeTypeDefault, type EdgeTypeDefinition, EdgeTypeError, EdgeTypeLoopBack, EdgeTypeMerge, EdgeTypeNormal, EdgeTypeParallel, EdgeTypeTimeout, type ExecutionConfig, type ExecutionContext, type ExecutionError, type ExecutionPathEntry, type ExpressionConfig, type ExpressionType, ExpressionTypeDSL, ExpressionTypeFilter, ExpressionTypeJavaScript, ExpressionTypeRules, ExpressionTypeTemplate, type GetWorkflowDefinitionByTitleRequest, type GetWorkflowDefinitionRequest, type GetWorkflowInstanceRequest, type HumanActionNodeSubType, HumanActionNodeSubTypes, type InstanceState, type InstanceStatus, InstanceStatusCompleted, InstanceStatusFailed, InstanceStatusNew, InstanceStatusPaused, InstanceStatusRunning, InstanceStatusWaiting, type Intent, type ListInstancesOptions, type ListWorkflowDefinitionsRequest, type ListWorkflowDefinitionsResponse, type ListWorkflowInstancesRequest, type ListWorkflowInstancesResponse, type LogicNodeSubType, LogicNodeSubTypes, type LogicPath, type LoopNodeSubType, LoopNodeSubTypes, type Metadata, type NodeCategory, type NodeConfig, type NodeDefinition, type NodeInput, type NodeInstance, type NodeOutput, type NodeSettings, type NodeState, type NodeStatus, NodeStatusCompleted, NodeStatusFailed, NodeStatusPending, NodeStatusRunning, NodeStatusSkipped, NodeStatusWaiting, type NodeSubType, NodeSubTypeActionApiCall, NodeSubTypeActionAssignSLAPolicy, NodeSubTypeActionCSATSurvey, NodeSubTypeActionChangeSLAStatus, NodeSubTypeActionCreateEntityRecord, NodeSubTypeActionDeleteEntityRecord, NodeSubTypeActionDocumentExtraction, NodeSubTypeActionEscalateSLA, NodeSubTypeActionGenerateDocument, NodeSubTypeActionMergeEntityRecords, NodeSubTypeActionNatsRequest, NodeSubTypeActionProcessPayment, NodeSubTypeActionQueryEntityRecords, NodeSubTypeActionSendEmail, NodeSubTypeActionSendSMS, NodeSubTypeActionSetVariables, NodeSubTypeActionUpdateEntityRecord, NodeSubTypeAgentApiIntegration, NodeSubTypeAgentChat, NodeSubTypeAgentClientApiCall, NodeSubTypeAgentCustomResponse, NodeSubTypeAgentIntentDetector, NodeSubTypeAgentKnowledgeGraph, NodeSubTypeAgentOpenTicket, NodeSubTypeAgentStructuredOutput, NodeSubTypeAgentTransferToHuman, NodeSubTypeDataCalculate, NodeSubTypeDataFilter, NodeSubTypeDataMap, NodeSubTypeDataValidate, NodeSubTypeDelay, NodeSubTypeHumanActionApproval, NodeSubTypeHumanActionAssignment, NodeSubTypeHumanActionDataEntry, NodeSubTypeHumanActionReview, type NodeSubTypeInfo, NodeSubTypeLogicFor, NodeSubTypeLogicIf, NodeSubTypeLogicParallel, NodeSubTypeLogicSwitch, NodeSubTypeLoopData, type NodeSubTypeTS, NodeSubTypeTimerBusinessHours, NodeSubTypeTimerDelay, NodeSubTypeTimerSchedule, NodeSubTypeTriggerEntityRecordCreated, NodeSubTypeTriggerEntityRecordDeleted, NodeSubTypeTriggerEntityRecordUpdated, NodeSubTypeTriggerEscalation, NodeSubTypeTriggerSLABreach, NodeSubTypeTriggerSLAWarning, NodeSubTypeTriggerStart, NodeSubTypeTriggerWebhookReceived, type NodeType, NodeTypeAccounting, NodeTypeAction, NodeTypeAgent, NodeTypeCustom, NodeTypeData, NodeTypeDelay, NodeTypeHumanAction, NodeTypeIntegration, NodeTypeLogic, NodeTypeLoop, NodeTypeParallel, NodeTypeSubflow, NodeTypeTimer, NodeTypeTrigger, type ParallelNodeSubType, ParallelNodeSubTypes, type PersistenceType, PersistenceTypeEphemeral, PersistenceTypePermanent, type ResponseMetadata, type RetryConfig, type RetryNodeRequest, type RuleLevel, RuleLevelError, RuleLevelInfo, RuleLevelWarning, SchemaBuilder, type SchemaBuilderProps, type SchemaBuilderUIComponents, type TimeoutAction, TimeoutActionAlt, TimeoutActionFail, TimeoutActionRetry, TimeoutActionSkip, type TimeoutConfig, type TimerNodeSubType, TimerNodeSubTypes, type TriggerNodeSubType, TriggerNodeSubTypes, type UpdateInstanceNodeMetadataRequest, type UpdateInstanceStatusRequest, type UpdateWorkflowDefinitionRequest, type UseWorkflowDefinitionOptions, type UseWorkflowDefinitionType, type UseWorkflowInstanceOptions, type UseWorkflowInstanceType, type WorkflowDefinition, WorkflowDefinitionContext, WorkflowDefinitionCreate, WorkflowDefinitionCreated, WorkflowDefinitionDelete, WorkflowDefinitionDeleted, WorkflowDefinitionGet, WorkflowDefinitionGetByTitle, WorkflowDefinitionGetServer, type WorkflowDefinitionInfo, WorkflowDefinitionList, WorkflowDefinitionProvider, type WorkflowDefinitionProviderProps, type WorkflowDefinitionResponse, type WorkflowDefinitionSelector, type WorkflowDefinitionState, WorkflowDefinitionUpdate, WorkflowDefinitionUpdated, type WorkflowEdge, type WorkflowEdgeTypeOptionTS, type WorkflowEdgeTypeTS, WorkflowEdgeTypes, WorkflowExecutionCompleted, WorkflowExecutionFailed, WorkflowExecutionStarted, type WorkflowInstance, WorkflowInstanceContext, WorkflowInstanceCreate, WorkflowInstanceExecuteNode, WorkflowInstanceExecuteNodeLean, type WorkflowInstanceExecuteNodeLeanRequest, WorkflowInstanceExecuteNodeLeanServer, type WorkflowInstanceExecuteNodeRequest, WorkflowInstanceExecuteNodeServer, WorkflowInstanceGet, WorkflowInstanceList, WorkflowInstanceProvider, type WorkflowInstanceProviderProps, type WorkflowInstanceResponse, WorkflowInstanceResumeNode, type WorkflowInstanceResumeNodeRequest, WorkflowInstanceResumeNodeServer, type WorkflowInstanceSelector, type WorkflowInstanceState, WorkflowInstanceUpdate, WorkflowInstanceUpdateNodeMetadata, WorkflowInstanceUpdated, type WorkflowMetadata, type WorkflowNode, type WorkflowNodeSubTypeTS, type WorkflowNodeTypeOptionTS, type WorkflowNodeTypeTS, WorkflowNodeTypes, type WorkflowPermissions, type WorkflowRule, WorkflowScheduleCreate, WorkflowScheduleDelete, WorkflowScheduleList, WorkflowSchedulePause, WorkflowScheduleResume, WorkflowScheduleUpdate, WorkflowTemplateGet, WorkflowTemplateInstantiate, WorkflowTemplateList, WorkflowTriggerFired, WorkflowTriggerPause, WorkflowTriggerRegister, WorkflowTriggerResume, WorkflowTriggerStatus, type WorkflowType, WorkflowTypeAgent, WorkflowTypeChat, type WorkflowTypeDefinition, WorkflowTypeDocument, WorkflowTypeEntity, type WorkflowTypeOptionTS, WorkflowTypeProductivity, type WorkflowTypeTS, WorkflowTypes, type WorkflowVariable, type WorkflowVariables, nodeDefinitions, nodeSchemas, useWorkflowDefinition, useWorkflowDefinitionContext, useWorkflowInstance, useWorkflowInstanceContext, workflowDefinitionReducer, workflowInstanceReducer };