@geenius/ai-workflow 0.1.0 → 0.4.0

package/packages/shared/dist/index.d.ts

@@ -0,0 +1,1368 @@
+import { z } from 'zod/v4';
+import { GeeniusError, ErrorCode } from '@geenius/tools/errors';
+
+/**
+ * @module WorkflowConfig
+ * @package @geenius/ai-workflow-shared
+ * @description Shared configuration helpers for the workflow runtime. This file
+ * defines the normalized execution options that the engine and UI bindings use
+ * to stay aligned on limits, timeouts, and telemetry defaults.
+ */
+/**
+ * Runtime configuration options accepted by the workflow package.
+ *
+ * @property maxSteps Maximum number of steps allowed in a definition.
+ * @property maxExecutionTimeMs Maximum allowed runtime for one execution.
+ * @property maxRetries Default retry count for retryable steps.
+ * @property defaultTimeout Default timeout for external operations.
+ * @property enableLogging Whether runtime logging is enabled.
+ * @property enableMetrics Whether metric capture is enabled.
+ */
+interface ConfigureWorkflowOptions {
+    maxSteps?: number;
+    maxExecutionTimeMs?: number;
+    maxRetries?: number;
+    defaultTimeout?: number;
+    enableLogging?: boolean;
+    enableMetrics?: boolean;
+}
+/**
+ * Normalized workflow runtime configuration.
+ *
+ * @property maxSteps Maximum number of steps allowed in a definition.
+ * @property maxExecutionTimeMs Maximum allowed runtime for one execution.
+ * @property maxRetries Default retry count for retryable steps.
+ * @property defaultTimeout Default timeout for external operations.
+ * @property enableLogging Whether runtime logging is enabled.
+ * @property enableMetrics Whether metric capture is enabled.
+ */
+interface WorkflowRuntimeConfig {
+    maxSteps: number;
+    maxExecutionTimeMs: number;
+    maxRetries: number;
+    defaultTimeout: number;
+    enableLogging: boolean;
+    enableMetrics: boolean;
+}
+/**
+ * Build a normalized workflow runtime configuration object.
+ *
+ * @param options Partial execution options supplied by the consumer.
+ * @returns A fully populated workflow runtime configuration.
+ *
+ * @example
+ * ```ts
+ * const config = configureWorkflow({
+ *   maxSteps: 50,
+ *   maxExecutionTimeMs: 3600000,
+ *   maxRetries: 3,
+ *   enableMetrics: true,
+ * })
+ * ```
+ */
+declare function configureWorkflow(options?: ConfigureWorkflowOptions): WorkflowRuntimeConfig;
+/**
+ * Default runtime configuration used when consumers do not override options.
+ */
+declare const defaultWorkflowConfig: WorkflowRuntimeConfig;
+
+/**
+ * @module WorkflowTypes
+ * @package @geenius/ai-workflow-shared
+ * @description Shared type contract for workflow definitions, step configs,
+ * execution runs, and builder state. Every framework variant and adapter layer
+ * imports these types to stay surface-compatible.
+ */
+/**
+ * Lifecycle state for a stored workflow definition.
+ */
+type WorkflowStatus = 'draft' | 'active' | 'paused' | 'archived';
+/**
+ * Lifecycle state for a workflow execution run.
+ */
+type RunStatus = 'pending' | 'running' | 'paused' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Lifecycle state for a single step execution result.
+ */
+type StepStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped' | 'waiting-approval';
+/**
+ * Discriminant for all built-in workflow step kinds.
+ */
+type StepType = 'llm-call' | 'transform' | 'condition' | 'human-approval' | 'webhook' | 'delay' | 'parallel' | 'loop' | 'sub-workflow' | 'custom';
+/**
+ * Serializable workflow definition consumed by the engine and UI packages.
+ *
+ * @property id Stable workflow identifier.
+ * @property name Human-readable workflow name.
+ * @property description Optional description shown in builders or catalogs.
+ * @property version Monotonic workflow definition version.
+ * @property status Lifecycle state for the definition.
+ * @property steps Ordered step definitions included in the workflow.
+ * @property connections Directed edges that form the workflow DAG.
+ * @property inputSchema Declared user inputs accepted by the workflow.
+ * @property variables Global variables available to all workflow steps.
+ * @property tags Optional classification tags for discovery and filtering.
+ * @property createdBy Identifier for the workflow author.
+ * @property createdAt Unix timestamp for initial creation.
+ * @property updatedAt Unix timestamp for the last definition update.
+ */
+interface WorkflowDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    version: number;
+    status: WorkflowStatus;
+    /** Steps in execution order */
+    steps: WorkflowStepDef[];
+    /** Connections between steps (DAG edges) */
+    connections: StepConnection[];
+    /** Input variables the workflow accepts */
+    inputSchema?: WorkflowVariable[];
+    /** Global variables available to all steps */
+    variables?: Record<string, unknown>;
+    /** Tags for organization */
+    tags?: string[];
+    createdBy: string;
+    createdAt: number;
+    updatedAt: number;
+}
+/**
+ * Definition for one step inside a workflow DAG.
+ *
+ * @property id Stable step identifier unique within the workflow.
+ * @property name Human-readable step label.
+ * @property type Step kind discriminant used by builders and executors.
+ * @property config Step-specific configuration payload.
+ * @property position Optional builder-canvas coordinates for the node.
+ * @property optional Whether the workflow may continue after this step fails.
+ * @property retries Optional retry policy for the step.
+ */
+interface WorkflowStepDef {
+    id: string;
+    name: string;
+    type: StepType;
+    /** Step-specific configuration */
+    config: StepConfig;
+    /** Position for visual builder */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Whether this step can be skipped on failure */
+    optional?: boolean;
+    /** Retry config */
+    retries?: {
+        maxAttempts: number;
+        backoffMs: number;
+    };
+}
+/**
+ * Union of all supported step configuration payloads.
+ */
+type StepConfig = LLMCallConfig | TransformConfig | ConditionConfig | HumanApprovalConfig | WebhookConfig | DelayConfig | ParallelConfig | LoopConfig | SubWorkflowConfig | CustomStepConfig;
+/**
+ * Configuration for an LLM invocation step.
+ *
+ * @property type Discriminant for the step config union.
+ * @property model Optional model identifier to execute against.
+ * @property systemPrompt System prompt applied before the user prompt.
+ * @property userPromptTemplate Interpolated user prompt template.
+ * @property temperature Optional creativity control for the model.
+ * @property maxTokens Optional output token limit.
+ * @property parseJson Whether the response should be parsed as JSON.
+ * @property outputVar Variable name that receives the step output.
+ */
+interface LLMCallConfig {
+    type: 'llm-call';
+    model?: string;
+    systemPrompt: string;
+    userPromptTemplate: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Parse response as JSON */
+    parseJson?: boolean;
+    /** Output variable name */
+    outputVar: string;
+}
+/**
+ * Configuration for a transform step that evaluates a data expression.
+ *
+ * @property type Discriminant for the step config union.
+ * @property expression Transform expression evaluated against workflow variables.
+ * @property inputVars Variable names required by the expression.
+ * @property outputVar Variable name that receives the transform result.
+ */
+interface TransformConfig {
+    type: 'transform';
+    /** JavaScript expression to evaluate (sandboxed) */
+    expression: string;
+    /** Input variable names */
+    inputVars: string[];
+    /** Output variable name */
+    outputVar: string;
+}
+/**
+ * Configuration for a conditional branch step.
+ *
+ * @property type Discriminant for the step config union.
+ * @property expression Boolean expression evaluated against workflow variables.
+ * @property trueStepId Step identifier selected when the expression is truthy.
+ * @property falseStepId Step identifier selected when the expression is falsy.
+ */
+interface ConditionConfig {
+    type: 'condition';
+    /** JavaScript expression that evaluates to boolean */
+    expression: string;
+    /** Step ID to go to if true */
+    trueStepId: string;
+    /** Step ID to go to if false */
+    falseStepId: string;
+}
+/**
+ * Configuration for a human approval gate.
+ *
+ * @property type Discriminant for the step config union.
+ * @property message Approval request message shown to operators.
+ * @property approvers Optional list of users or roles allowed to approve.
+ * @property autoApproveAfterMs Optional timeout before auto-approval.
+ */
+interface HumanApprovalConfig {
+    type: 'human-approval';
+    message: string;
+    /** Who can approve */
+    approvers?: string[];
+    /** Auto-approve after timeout (ms) */
+    autoApproveAfterMs?: number;
+}
+/**
+ * Configuration for an outbound webhook step.
+ *
+ * @property type Discriminant for the step config union.
+ * @property url Target endpoint URL.
+ * @property method HTTP method used for the request.
+ * @property headers Optional request headers.
+ * @property bodyTemplate Optional interpolated request body template.
+ * @property outputVar Variable name that receives the webhook response.
+ */
+interface WebhookConfig {
+    type: 'webhook';
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+    headers?: Record<string, string>;
+    bodyTemplate?: string;
+    outputVar: string;
+}
+/**
+ * Configuration for a wait or backoff step.
+ *
+ * @property type Discriminant for the step config union.
+ * @property durationMs Delay duration in milliseconds.
+ */
+interface DelayConfig {
+    type: 'delay';
+    durationMs: number;
+}
+/**
+ * Configuration for a fan-out step that runs multiple children concurrently.
+ *
+ * @property type Discriminant for the step config union.
+ * @property stepIds Step identifiers executed in parallel.
+ * @property failurePolicy Failure handling policy for the parallel branch.
+ */
+interface ParallelConfig {
+    type: 'parallel';
+    /** Step IDs to execute in parallel */
+    stepIds: string[];
+    /** How to handle failures: 'fail-fast' or 'continue' */
+    failurePolicy: 'fail-fast' | 'continue';
+}
+/**
+ * Configuration for iterating over a collection of values.
+ *
+ * @property type Discriminant for the step config union.
+ * @property stepIds Step identifiers executed for each iteration.
+ * @property iterateVar Variable name containing the input collection.
+ * @property itemVar Variable name exposed for the current item.
+ * @property maxIterations Optional safety cap for loop iterations.
+ */
+interface LoopConfig {
+    type: 'loop';
+    /** Step IDs to loop over */
+    stepIds: string[];
+    /** Variable containing the array to iterate */
+    iterateVar: string;
+    /** Variable name for current item */
+    itemVar: string;
+    /** Max iterations */
+    maxIterations?: number;
+}
+/**
+ * Configuration for invoking another stored workflow definition.
+ *
+ * @property type Discriminant for the step config union.
+ * @property workflowId Referenced workflow identifier.
+ * @property inputMapping Mapping from local variables to child workflow inputs.
+ * @property outputVar Variable name that receives the sub-workflow result.
+ */
+interface SubWorkflowConfig {
+    type: 'sub-workflow';
+    workflowId: string;
+    inputMapping: Record<string, string>;
+    outputVar: string;
+}
+/**
+ * Configuration for a user-provided custom handler step.
+ *
+ * @property type Discriminant for the step config union.
+ * @property handler Registered custom handler name.
+ * @property params Arbitrary parameters passed to the handler.
+ * @property outputVar Optional variable name that receives the handler result.
+ */
+interface CustomStepConfig {
+    type: 'custom';
+    handler: string;
+    params: Record<string, unknown>;
+    outputVar?: string;
+}
+/**
+ * Directed edge between two workflow steps.
+ *
+ * @property fromStepId Source step identifier.
+ * @property toStepId Destination step identifier.
+ * @property label Optional edge label for builder displays.
+ * @property condition Optional condition label for branching edges.
+ */
+interface StepConnection {
+    fromStepId: string;
+    toStepId: string;
+    /** Optional label for the connection */
+    label?: string;
+    /** Condition for conditional edges */
+    condition?: string;
+}
+/**
+ * Definition for one declared workflow input or variable.
+ *
+ * @property name Variable identifier.
+ * @property type Primitive or structured variable kind.
+ * @property description Optional explanatory text for consumers.
+ * @property required Whether the variable must be supplied.
+ * @property default Optional default value used when none is supplied.
+ */
+interface WorkflowVariable {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    required?: boolean;
+    default?: unknown;
+}
+/**
+ * Runtime snapshot for one workflow execution.
+ *
+ * @property id Stable run identifier.
+ * @property workflowId Identifier of the executed workflow.
+ * @property workflowVersion Definition version used for this run.
+ * @property status Current lifecycle state for the run.
+ * @property input Input payload supplied to the execution.
+ * @property variables Current workflow variable bag.
+ * @property stepResults Per-step execution results accumulated so far.
+ * @property currentStepIndex Index of the step currently being executed.
+ * @property error Optional terminal error message for failed runs.
+ * @property triggeredBy Actor identifier that initiated the run.
+ * @property startedAt Unix timestamp when execution began.
+ * @property completedAt Optional Unix timestamp when execution finished.
+ */
+interface WorkflowRun {
+    id: string;
+    workflowId: string;
+    workflowVersion: number;
+    status: RunStatus;
+    /** Input variables provided */
+    input: Record<string, unknown>;
+    /** Current workflow variables state */
+    variables: Record<string, unknown>;
+    /** Step execution results */
+    stepResults: StepResult[];
+    /** Current step index */
+    currentStepIndex: number;
+    /** Error if failed */
+    error?: string;
+    /** Who triggered the run */
+    triggeredBy: string;
+    startedAt: number;
+    completedAt?: number;
+}
+/**
+ * Runtime result captured for one executed workflow step.
+ *
+ * @property stepId Identifier of the executed step.
+ * @property stepName Human-readable step name.
+ * @property type Step kind discriminant.
+ * @property status Execution status for the step.
+ * @property input Optional input variables visible to the step.
+ * @property output Optional output produced by the step.
+ * @property error Optional error message for failed steps.
+ * @property durationMs Step duration in milliseconds.
+ * @property tokens Optional token usage for LLM-backed steps.
+ * @property costUsd Optional cost metadata for LLM-backed steps.
+ * @property startedAt Unix timestamp when the step started.
+ * @property completedAt Optional Unix timestamp when the step finished.
+ */
+interface StepResult {
+    stepId: string;
+    stepName: string;
+    type: StepType;
+    status: StepStatus;
+    /** Input variables for this step */
+    input?: Record<string, unknown>;
+    /** Output from this step */
+    output?: unknown;
+    /** Error message */
+    error?: string;
+    /** Duration */
+    durationMs: number;
+    /** Tokens used (for LLM steps) */
+    tokens?: number;
+    /** Cost (for LLM steps) */
+    costUsd?: number;
+    startedAt: number;
+    completedAt?: number;
+}
+/**
+ * Mutable UI state tracked by builder primitives and hooks.
+ *
+ * @property definition Current workflow definition being edited.
+ * @property selectedStepId Currently selected step identifier.
+ * @property isDirty Whether unsaved local edits exist.
+ * @property undoStack Historical definitions for undo support.
+ * @property redoStack Historical definitions for redo support.
+ */
+interface WorkflowBuilderState {
+    definition: WorkflowDefinition;
+    selectedStepId: string | null;
+    isDirty: boolean;
+    undoStack: WorkflowDefinition[];
+    redoStack: WorkflowDefinition[];
+}
+
+/**
+ * @module WorkflowEngine
+ * @package @geenius/ai-workflow-shared
+ * @description Runtime execution engine for workflow definitions. This file
+ * walks the declared DAG in execution order, normalizes retry/error handling,
+ * and captures run state that every UI variant can render consistently.
+ */
+
+/**
+ * Runtime dependencies injected into the workflow engine.
+ *
+ * The engine stays framework-agnostic by requiring callers to provide LLM,
+ * webhook, approval, and custom-step integrations explicitly.
+ */
+interface WorkflowEngineOptions {
+    /** LLM call function for llm-call steps */
+    callLLM?: (systemPrompt: string, userPrompt: string, model?: string) => Promise<{
+        content: string;
+        tokens?: number;
+        costUsd?: number;
+    }>;
+    /** Webhook call function */
+    callWebhook?: (url: string, method: string, body?: string, headers?: Record<string, string>) => Promise<string>;
+    /** Human approval callback */
+    onApprovalRequired?: (message: string, stepId: string) => Promise<boolean>;
+    /** Step event callback */
+    onStepComplete?: (result: StepResult) => void;
+    /** Custom step handlers */
+    customHandlers?: Record<string, (params: Record<string, unknown>, vars: Record<string, unknown>) => Promise<unknown>>;
+}
+/**
+ * Executes workflow definitions against provided runtime integrations.
+ */
+declare class WorkflowEngine {
+    private options;
+    private cancelled;
+    constructor(options: WorkflowEngineOptions);
+    /**
+     * Cancel the in-flight execution loop before the next step begins.
+     */
+    cancel(): void;
+    /**
+     * Execute a workflow definition from start to finish and capture the full
+     * run state for UI or persistence layers.
+     */
+    execute(definition: WorkflowDefinition, input?: Record<string, unknown>): Promise<WorkflowRun>;
+    /**
+     * Execute one step with retry handling and normalized result capture.
+     */
+    private executeStep;
+    /**
+     * Run the concrete logic for an individual step type.
+     */
+    private runStepLogic;
+    /** Interpolate `{{variable}}` references in a string. */
+    private interpolate;
+    private buildExpressionScope;
+    /** Topological sort of steps based on declared workflow connections. */
+    private topoSort;
+}
+
+/**
+ * @module WorkflowStepFactories
+ * @package @geenius/ai-workflow-shared
+ * @description Built-in step factory helpers for constructing shared workflow
+ * definitions in a concise and type-safe way.
+ */
+
+/**
+ * Create an LLM call step definition with a generated identifier.
+ *
+ * @param name Human-readable step name.
+ * @param config Step configuration without the discriminant.
+ * @returns A workflow step definition ready for insertion into a workflow.
+ */
+declare function llmStep(name: string, config: Omit<LLMCallConfig, 'type'>): WorkflowStepDef;
+/**
+ * Create a data transform step definition with a generated identifier.
+ *
+ * @param name Human-readable step name.
+ * @param config Step configuration without the discriminant.
+ * @returns A workflow step definition ready for insertion into a workflow.
+ */
+declare function transformStep(name: string, config: Omit<TransformConfig, 'type'>): WorkflowStepDef;
+/**
+ * Create a conditional branch step definition with a generated identifier.
+ *
+ * @param name Human-readable step name.
+ * @param config Step configuration without the discriminant.
+ * @returns A workflow step definition ready for insertion into a workflow.
+ */
+declare function conditionStep(name: string, config: Omit<ConditionConfig, 'type'>): WorkflowStepDef;
+/**
+ * Create a human approval step definition with a generated identifier.
+ *
+ * @param name Human-readable step name.
+ * @param config Step configuration without the discriminant.
+ * @returns A workflow step definition ready for insertion into a workflow.
+ */
+declare function approvalStep(name: string, config: Omit<HumanApprovalConfig, 'type'>): WorkflowStepDef;
+/**
+ * Create a webhook step definition with a generated identifier.
+ *
+ * @param name Human-readable step name.
+ * @param config Step configuration without the discriminant.
+ * @returns A workflow step definition ready for insertion into a workflow.
+ */
+declare function webhookStep(name: string, config: Omit<WebhookConfig, 'type'>): WorkflowStepDef;
+/**
+ * Create a delay step definition with a generated identifier.
+ *
+ * @param name Human-readable step name.
+ * @param durationMs Delay duration in milliseconds.
+ * @returns A workflow step definition ready for insertion into a workflow.
+ */
+declare function delayStep(name: string, durationMs: number): WorkflowStepDef;
+/**
+ * Connect two steps (create a DAG edge).
+ *
+ * @param fromStepId Source step identifier.
+ * @param toStepId Destination step identifier.
+ * @param label Optional edge label for builder displays.
+ * @returns A directed connection between the two steps.
+ */
+declare function connect(fromStepId: string, toStepId: string, label?: string): {
+    fromStepId: string;
+    toStepId: string;
+    label?: string;
+};
+/**
+ * Build a linear workflow from an ordered list of steps.
+ *
+ * @param name Unused descriptive name retained for factory API parity.
+ * @param steps Ordered list of workflow steps.
+ * @returns The original steps paired with sequential connections.
+ */
+declare function linearWorkflow(name: string, steps: WorkflowStepDef[]): {
+    steps: WorkflowStepDef[];
+    connections: Array<{
+        fromStepId: string;
+        toStepId: string;
+    }>;
+};
+
+/**
+ * @module WorkflowValidators
+ * @package @geenius/ai-workflow-shared
+ * @description Zod schemas and validation helpers for workflow definitions,
+ * step configs, runtime results, and graph integrity checks.
+ */
+
+/**
+ * Discriminated union covering every supported step configuration schema.
+ */
+declare const stepConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"llm-call">;
+    model: z.ZodOptional<z.ZodString>;
+    systemPrompt: z.ZodString;
+    userPromptTemplate: z.ZodString;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    parseJson: z.ZodOptional<z.ZodBoolean>;
+    outputVar: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"transform">;
+    expression: z.ZodString;
+    inputVars: z.ZodArray<z.ZodString>;
+    outputVar: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"condition">;
+    expression: z.ZodString;
+    trueStepId: z.ZodString;
+    falseStepId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"human-approval">;
+    message: z.ZodString;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    autoApproveAfterMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"webhook">;
+    url: z.ZodString;
+    method: z.ZodEnum<{
+        GET: "GET";
+        POST: "POST";
+        PUT: "PUT";
+        DELETE: "DELETE";
+    }>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    bodyTemplate: z.ZodOptional<z.ZodString>;
+    outputVar: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"delay">;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"parallel">;
+    stepIds: z.ZodArray<z.ZodString>;
+    failurePolicy: z.ZodEnum<{
+        "fail-fast": "fail-fast";
+        continue: "continue";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"loop">;
+    stepIds: z.ZodArray<z.ZodString>;
+    iterateVar: z.ZodString;
+    itemVar: z.ZodString;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"sub-workflow">;
+    workflowId: z.ZodString;
+    inputMapping: z.ZodRecord<z.ZodString, z.ZodString>;
+    outputVar: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"custom">;
+    handler: z.ZodString;
+    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    outputVar: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+/**
+ * Zod schema for one workflow step definition.
+ */
+declare const workflowStepDefSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        "llm-call": "llm-call";
+        transform: "transform";
+        condition: "condition";
+        "human-approval": "human-approval";
+        webhook: "webhook";
+        delay: "delay";
+        parallel: "parallel";
+        loop: "loop";
+        "sub-workflow": "sub-workflow";
+        custom: "custom";
+    }>;
+    config: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"llm-call">;
+        model: z.ZodOptional<z.ZodString>;
+        systemPrompt: z.ZodString;
+        userPromptTemplate: z.ZodString;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        parseJson: z.ZodOptional<z.ZodBoolean>;
+        outputVar: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"transform">;
+        expression: z.ZodString;
+        inputVars: z.ZodArray<z.ZodString>;
+        outputVar: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"condition">;
+        expression: z.ZodString;
+        trueStepId: z.ZodString;
+        falseStepId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"human-approval">;
+        message: z.ZodString;
+        approvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        autoApproveAfterMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"webhook">;
+        url: z.ZodString;
+        method: z.ZodEnum<{
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            DELETE: "DELETE";
+        }>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        bodyTemplate: z.ZodOptional<z.ZodString>;
+        outputVar: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"delay">;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"parallel">;
+        stepIds: z.ZodArray<z.ZodString>;
+        failurePolicy: z.ZodEnum<{
+            "fail-fast": "fail-fast";
+            continue: "continue";
+        }>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"loop">;
+        stepIds: z.ZodArray<z.ZodString>;
+        iterateVar: z.ZodString;
+        itemVar: z.ZodString;
+        maxIterations: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"sub-workflow">;
+        workflowId: z.ZodString;
+        inputMapping: z.ZodRecord<z.ZodString, z.ZodString>;
+        outputVar: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"custom">;
+        handler: z.ZodString;
+        params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        outputVar: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>;
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    retries: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodNumber;
+        backoffMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Zod schema for directed graph edges between workflow steps.
+ */
+declare const stepConnectionSchema: z.ZodObject<{
+    fromStepId: z.ZodString;
+    toStepId: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    condition: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod schema for declared workflow inputs and variables.
+ */
+declare const workflowVariableSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        array: "array";
+    }>;
+    description: z.ZodOptional<z.ZodString>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a persisted workflow definition.
+ */
+declare const workflowDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    version: z.ZodNumber;
+    status: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        paused: "paused";
+        archived: "archived";
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            "llm-call": "llm-call";
+            transform: "transform";
+            condition: "condition";
+            "human-approval": "human-approval";
+            webhook: "webhook";
+            delay: "delay";
+            parallel: "parallel";
+            loop: "loop";
+            "sub-workflow": "sub-workflow";
+            custom: "custom";
+        }>;
+        config: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"llm-call">;
+            model: z.ZodOptional<z.ZodString>;
+            systemPrompt: z.ZodString;
+            userPromptTemplate: z.ZodString;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            parseJson: z.ZodOptional<z.ZodBoolean>;
+            outputVar: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"transform">;
+            expression: z.ZodString;
+            inputVars: z.ZodArray<z.ZodString>;
+            outputVar: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"condition">;
+            expression: z.ZodString;
+            trueStepId: z.ZodString;
+            falseStepId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"human-approval">;
+            message: z.ZodString;
+            approvers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            autoApproveAfterMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"webhook">;
+            url: z.ZodString;
+            method: z.ZodEnum<{
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                DELETE: "DELETE";
+            }>;
+            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            bodyTemplate: z.ZodOptional<z.ZodString>;
+            outputVar: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"delay">;
+            durationMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"parallel">;
+            stepIds: z.ZodArray<z.ZodString>;
+            failurePolicy: z.ZodEnum<{
+                "fail-fast": "fail-fast";
+                continue: "continue";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"loop">;
+            stepIds: z.ZodArray<z.ZodString>;
+            iterateVar: z.ZodString;
+            itemVar: z.ZodString;
+            maxIterations: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"sub-workflow">;
+            workflowId: z.ZodString;
+            inputMapping: z.ZodRecord<z.ZodString, z.ZodString>;
+            outputVar: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"custom">;
+            handler: z.ZodString;
+            params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            outputVar: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>;
+        position: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>;
+        optional: z.ZodOptional<z.ZodBoolean>;
+        retries: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodNumber;
+            backoffMs: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    connections: z.ZodArray<z.ZodObject<{
+        fromStepId: z.ZodString;
+        toStepId: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        condition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    inputSchema: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    createdBy: z.ZodString;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Zod schema for one captured step result inside a workflow run.
+ */
+declare const stepResultSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    stepName: z.ZodString;
+    type: z.ZodEnum<{
+        "llm-call": "llm-call";
+        transform: "transform";
+        condition: "condition";
+        "human-approval": "human-approval";
+        webhook: "webhook";
+        delay: "delay";
+        parallel: "parallel";
+        loop: "loop";
+        "sub-workflow": "sub-workflow";
+        custom: "custom";
+    }>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        skipped: "skipped";
+        "waiting-approval": "waiting-approval";
+    }>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    tokens: z.ZodOptional<z.ZodNumber>;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodNumber;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Zod schema for a full workflow execution run snapshot.
+ */
+declare const workflowRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    workflowId: z.ZodString;
+    workflowVersion: z.ZodNumber;
+    status: z.ZodEnum<{
+        paused: "paused";
+        pending: "pending";
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    variables: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    stepResults: z.ZodArray<z.ZodObject<{
+        stepId: z.ZodString;
+        stepName: z.ZodString;
+        type: z.ZodEnum<{
+            "llm-call": "llm-call";
+            transform: "transform";
+            condition: "condition";
+            "human-approval": "human-approval";
+            webhook: "webhook";
+            delay: "delay";
+            parallel: "parallel";
+            loop: "loop";
+            "sub-workflow": "sub-workflow";
+            custom: "custom";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            running: "running";
+            completed: "completed";
+            failed: "failed";
+            skipped: "skipped";
+            "waiting-approval": "waiting-approval";
+        }>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        error: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodNumber;
+        tokens: z.ZodOptional<z.ZodNumber>;
+        costUsd: z.ZodOptional<z.ZodNumber>;
+        startedAt: z.ZodNumber;
+        completedAt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    currentStepIndex: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    triggeredBy: z.ZodString;
+    startedAt: z.ZodNumber;
+    completedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Validate an unknown payload as a workflow definition.
+ *
+ * @param data Unknown payload to validate.
+ * @returns A safe-parse result containing the validated definition or errors.
+ */
+declare function validateWorkflow(data: unknown): z.ZodSafeParseResult<z.infer<typeof workflowDefinitionSchema>>;
+/**
+ * Validate an unknown payload as a workflow run snapshot.
+ *
+ * @param data Unknown payload to validate.
+ * @returns A safe-parse result containing the validated run or errors.
+ */
+declare function validateRun(data: unknown): z.ZodSafeParseResult<z.infer<typeof workflowRunSchema>>;
+/**
+ * Validate that all connections reference known step identifiers.
+ *
+ * @param steps Declared workflow steps.
+ * @param connections Directed edges between those steps.
+ * @returns A list of integrity errors, empty when every reference is valid.
+ */
+declare function validateConnectionIntegrity(steps: Array<{
+    id: string;
+}>, connections: Array<{
+    fromStepId: string;
+    toStepId: string;
+}>): string[];
+
+/**
+ * @module WorkflowErrors
+ * @package @geenius/ai-workflow-shared
+ * @description Package-specific typed error classes for workflow configuration,
+ * execution, graph validation, and expression evaluation. These errors extend
+ * the shared Geenius error base so consumers can discriminate failures safely.
+ */
+
+/**
+ * Shared context payload for workflow failures.
+ *
+ * @property stepId Optional workflow step identifier related to the failure.
+ * @property workflowId Optional workflow identifier related to the failure.
+ * @property expression Optional expression string that failed to parse or evaluate.
+ * @property details Arbitrary structured metadata that helps consumers debug failures.
+ */
+interface WorkflowErrorContext {
+    [key: string]: unknown;
+    stepId?: string;
+    workflowId?: string;
+    expression?: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Base typed error for the AI workflow package.
+ */
+declare class WorkflowError extends GeeniusError {
+    /**
+     * Create a structured workflow error.
+     *
+     * @param options Error metadata, message, and optional structured context.
+     * @returns A typed workflow error instance.
+     */
+    constructor(options: {
+        code?: ErrorCode;
+        message: string;
+        cause?: unknown;
+        context?: WorkflowErrorContext;
+    });
+}
+/**
+ * Error raised when workflow configuration is invalid or incomplete.
+ */
+declare class WorkflowConfigurationError extends WorkflowError {
+    /**
+     * Create a configuration error for invalid workflow setup.
+     *
+     * @param message Human-readable explanation of the invalid configuration.
+     * @param context Optional structured metadata describing the failing config area.
+     * @returns A typed workflow configuration error.
+     */
+    constructor(message: string, context?: WorkflowErrorContext);
+}
+/**
+ * Error raised when workflow execution fails at runtime.
+ */
+declare class WorkflowExecutionError extends WorkflowError {
+    /**
+     * Create an execution error for a workflow runtime failure.
+     *
+     * @param message Human-readable explanation of the runtime failure.
+     * @param context Optional structured metadata describing the failing execution path.
+     * @param cause Optional underlying exception that triggered the runtime failure.
+     * @returns A typed workflow execution error.
+     */
+    constructor(message: string, context?: WorkflowErrorContext, cause?: unknown);
+}
+/**
+ * Error raised when a workflow DAG is invalid.
+ */
+declare class WorkflowGraphError extends WorkflowError {
+    /**
+     * Create a graph-validation error for an invalid workflow topology.
+     *
+     * @param message Human-readable explanation of the graph validation failure.
+     * @param context Optional structured metadata describing the invalid topology.
+     * @returns A typed workflow graph error.
+     */
+    constructor(message: string, context?: WorkflowErrorContext);
+}
+/**
+ * Error raised when workflow expressions fail to parse or evaluate safely.
+ */
+declare class WorkflowExpressionError extends WorkflowError {
+    /**
+     * Create an expression error for a failed transform or condition expression.
+     *
+     * @param message Human-readable explanation of the expression failure.
+     * @param context Optional structured metadata including the source expression.
+     * @param cause Optional underlying parse or runtime error.
+     * @returns A typed workflow expression error.
+     */
+    constructor(message: string, context?: WorkflowErrorContext, cause?: unknown);
+}
+/**
+ * Normalize unknown thrown values into an exported workflow error type.
+ *
+ * @param error Unknown thrown value from workflow code.
+ * @param fallbackMessage Message used when the original value is not informative.
+ * @param context Optional structured context describing the failing workflow area.
+ * @returns A typed workflow error instance suitable for rethrowing or storing.
+ */
+declare function normalizeWorkflowError(error: unknown, fallbackMessage: string, context?: WorkflowErrorContext): WorkflowError;
+
+/**
+ * @module WorkflowTemplates
+ * @package @geenius/ai-workflow-shared
+ * @description Curated workflow templates for common AI and business patterns.
+ * These templates seed the builder UI and provide canonical examples of the
+ * shared workflow definition contract.
+ */
+
+/**
+ * Template metadata and factory for one reusable workflow starter.
+ *
+ * @property id Stable template identifier.
+ * @property name Human-readable template name.
+ * @property description Summary of the workflow pattern.
+ * @property category Top-level template grouping used in browsers.
+ * @property tags Searchable tags for discovery.
+ * @property create Factory that returns a fresh workflow definition instance.
+ */
+interface WorkflowTemplate {
+    id: string;
+    name: string;
+    description: string;
+    category: 'content' | 'data' | 'approval' | 'research' | 'devops';
+    tags: string[];
+    /** Factory that creates a fresh WorkflowDefinition from this template */
+    create: (createdBy: string) => WorkflowDefinition;
+}
+/**
+ * Canonical template catalog shipped with the package.
+ */
+declare const WORKFLOW_TEMPLATES: WorkflowTemplate[];
+/**
+ * Look up one workflow template by its stable identifier.
+ *
+ * @param id Template identifier to resolve.
+ * @returns The matching workflow template when found.
+ */
+declare function getTemplate(id: string): WorkflowTemplate | undefined;
+/**
+ * Return every workflow template that belongs to one category.
+ *
+ * @param category Template category to filter by.
+ * @returns Templates whose category matches the requested value.
+ */
+declare function getTemplatesByCategory(category: WorkflowTemplate['category']): WorkflowTemplate[];
+
+/**
+ * @module WorkflowInterpolationUtils
+ * @package @geenius/ai-workflow-shared
+ * @description Template-variable interpolation helpers for workflow prompts,
+ * webhook bodies, and approval copy. These functions resolve dot paths and
+ * replace `{{variable}}` markers using the workflow runtime context.
+ */
+/**
+ * Interpolate {{variable}} or {{nested.path}} references in a string.
+ * Supports optional default values: {{varName|default}}.
+ */
+declare function interpolate(template: string, vars: Record<string, unknown>): string;
+/**
+ * Extract all variable references from a template string.
+ * Returns unique variable names (without defaults).
+ */
+declare function extractVariables(template: string): string[];
+/**
+ * Check if all required variables in a template are present in the vars object.
+ * Returns missing variable names.
+ */
+declare function findMissingVariables(template: string, vars: Record<string, unknown>): string[];
+
+/**
+ * @module WorkflowExpressionUtils
+ * @package @geenius/ai-workflow-shared
+ * @description Safe expression helpers for transform and condition steps. This
+ * file implements the parser and evaluator used by the workflow engine to
+ * support a constrained JavaScript-like expression language without `eval`.
+ */
+/**
+ * Evaluate a workflow expression against the provided variables.
+ */
+declare function evaluateExpression(expression: string, context: Record<string, unknown>): unknown;
+
+/**
+ * @module WorkflowDagUtils
+ * @package @geenius/ai-workflow-shared
+ * @description Directed-acyclic-graph helpers used by the workflow engine and
+ * validators. These utilities normalize graph traversal, cycle detection, and
+ * entry/exit analysis across every framework variant.
+ */
+/**
+ * Minimal graph node shape accepted by DAG helpers.
+ */
+interface DAGNode {
+    id: string;
+}
+/**
+ * Minimal graph edge shape accepted by DAG helpers.
+ */
+interface DAGEdge {
+    from: string;
+    to: string;
+}
+/**
+ * Topological sort using Kahn's algorithm.
+ * Returns sorted node IDs or throws if a cycle is detected.
+ */
+declare function topoSort(nodeIds: string[], edges: DAGEdge[]): string[];
+/**
+ * Detect cycles using DFS. Returns the cycle path if one exists, or null.
+ */
+declare function detectCycle(nodeIds: string[], edges: DAGEdge[]): string[] | null;
+/**
+ * Find all paths from source to target in the DAG.
+ */
+declare function findPaths(nodeIds: string[], edges: DAGEdge[], source: string, target: string): string[][];
+/**
+ * Find entry nodes (no incoming edges) in the DAG.
+ */
+declare function findEntryNodes(nodeIds: string[], edges: DAGEdge[]): string[];
+/**
+ * Find exit nodes (no outgoing edges) in the DAG.
+ */
+declare function findExitNodes(nodeIds: string[], edges: DAGEdge[]): string[];
+
+/**
+ * @module WorkflowCostUtils
+ * @package @geenius/ai-workflow-shared
+ * @description Cost and token estimation helpers for workflow definitions and
+ * completed runs. These utilities keep LLM spend reporting consistent across
+ * the builder, run panel, and Storybook surfaces.
+ */
+
+/** Cost-per-token rates by model (USD per 1K tokens) */
+declare const MODEL_RATES: Record<string, {
+    input: number;
+    output: number;
+}>;
+/** Rough token estimation (1 token ≈ 4 chars for English text) */
+declare function estimateTokens(text: string): number;
+/** Estimate the token count for an LLM step */
+declare function estimateStepTokens(config: LLMCallConfig, vars?: Record<string, unknown>): {
+    inputTokens: number;
+    outputTokens: number;
+};
+/** Estimate cost for a single step */
+declare function estimateStepCost(config: LLMCallConfig, vars?: Record<string, unknown>): number;
+/** Estimate total cost for an entire workflow definition */
+declare function estimateWorkflowCost(definition: WorkflowDefinition, vars?: Record<string, unknown>): {
+    totalCostUsd: number;
+    totalTokens: number;
+    stepEstimates: Array<{
+        stepId: string;
+        stepName: string;
+        costUsd: number;
+        tokens: number;
+    }>;
+};
+/** Calculate actual cost from completed step results */
+declare function calculateRunCost(results: StepResult[]): {
+    totalCostUsd: number;
+    totalTokens: number;
+};
+/** Format cost as a human-readable string */
+declare function formatCost(usd: number): string;
+
+/**
+ * @module WorkflowConvexSchemaFields
+ * @package @geenius/ai-workflow-shared
+ * @description Typed Convex-style schema manifests for the workflow package.
+ * These structured objects preserve field shape so consumers can persist and
+ * query workflow payloads without losing typed storage metadata.
+ */
+type LiteralField<T extends string | number | boolean> = {
+    type: 'literal';
+    value: T;
+    optional?: true;
+};
+type StringField = {
+    type: 'string';
+    optional?: true;
+};
+type NumberField = {
+    type: 'number';
+    optional?: true;
+};
+type BooleanField = {
+    type: 'boolean';
+    optional?: true;
+};
+type UnknownField = {
+    type: 'any';
+    optional?: true;
+};
+type ArrayField = {
+    type: 'array';
+    items: SchemaField;
+    optional?: true;
+};
+type RecordField = {
+    type: 'record';
+    key: SchemaField;
+    value: SchemaField;
+    optional?: true;
+};
+type ObjectField = {
+    type: 'object';
+    fields: Record<string, SchemaField>;
+    optional?: true;
+};
+type UnionField = {
+    type: 'union';
+    values: SchemaField[];
+    optional?: true;
+};
+/**
+ * Typed schema field descriptor used to describe Convex document shapes.
+ */
+type SchemaField = LiteralField<string | number | boolean> | StringField | NumberField | BooleanField | UnknownField | ArrayField | RecordField | ObjectField | UnionField;
+/**
+ * Manifest describing persisted workflow definition documents.
+ */
+declare const workflowsTable: ObjectField;
+/**
+ * Manifest describing persisted workflow execution run documents.
+ */
+declare const workflowRunsTable: ObjectField;
+/**
+ * Manifest describing persisted per-step execution result documents.
+ */
+declare const workflowStepResultsTable: ObjectField;
+/**
+ * Named collection of all workflow table manifests for consumer schema merges.
+ */
+declare const workflowTables: {
+    workflows: ObjectField;
+    workflowRuns: ObjectField;
+    workflowStepResults: ObjectField;
+};
+
+export { type ConditionConfig, type ConfigureWorkflowOptions, type CustomStepConfig, type DAGEdge, type DAGNode, type DelayConfig, type HumanApprovalConfig, type LLMCallConfig, type LoopConfig, MODEL_RATES, type ParallelConfig, type RunStatus, type StepConfig, type StepConnection, type StepResult, type StepStatus, type StepType, type SubWorkflowConfig, type TransformConfig, WORKFLOW_TEMPLATES, type WebhookConfig, type WorkflowBuilderState, WorkflowConfigurationError, type WorkflowDefinition, WorkflowEngine, type WorkflowEngineOptions, WorkflowError, type WorkflowErrorContext, WorkflowExecutionError, WorkflowExpressionError, WorkflowGraphError, type WorkflowRun, type WorkflowStatus, type WorkflowStepDef, type WorkflowTemplate, type WorkflowVariable, approvalStep, calculateRunCost, conditionStep, configureWorkflow, connect, defaultWorkflowConfig, delayStep, detectCycle, estimateStepCost, estimateStepTokens, estimateTokens, estimateWorkflowCost, evaluateExpression, extractVariables, findEntryNodes, findExitNodes, findMissingVariables, findPaths, formatCost, getTemplate, getTemplatesByCategory, interpolate, linearWorkflow, llmStep, normalizeWorkflowError, stepConfigSchema, stepConnectionSchema, stepResultSchema, topoSort, transformStep, validateConnectionIntegrity, validateRun, validateWorkflow, webhookStep, workflowDefinitionSchema, workflowRunSchema, workflowRunsTable, workflowStepDefSchema, workflowStepResultsTable, workflowTables, workflowVariableSchema, workflowsTable };