@renseiai/agentfactory 0.8.12 → 0.8.13

package/dist/src/workflow/workflow-types.d.ts

@@ -6,8 +6,11 @@
  * escalation ladder, gates, and parallelism — in YAML rather than hard-coded
  * TypeScript.
  *
- * This is an additive v1.1 schema extension. Existing v1 WorkflowTemplate
- * and PartialTemplate documents remain valid and unchanged.
+ * Supports two schema versions:
+ * - **v1.1**: Phase-based workflow with template bindings, transitions, escalation
+ * - **v2**: Event-driven workflow with triggers, providers, config, and multi-step nodes
+ *
+ * Use {@link AnyWorkflowDefinition} for consumers that handle both versions.
  */
 import { z } from 'zod';
 /**
@@ -264,6 +267,127 @@ export interface BranchingDefinition {
         timeout?: TemplateTimeoutConfig;
     };
 }
+/**
+ * Declares an event that can initiate workflow execution.
+ * Triggers define the source, event type, and optional payload filter.
+ */
+export interface WorkflowTriggerDefinition {
+    /** Unique trigger name */
+    name: string;
+    /** Trigger type: webhook (external event), schedule (cron), manual (user-initiated) */
+    type: 'webhook' | 'schedule' | 'manual';
+    /** Provider name (e.g., 'linear') — identifies the event source */
+    source?: string;
+    /** Event type (e.g., 'issue.status_changed') */
+    event?: string;
+    /** Event payload filter — only fire when payload matches */
+    filter?: Record<string, unknown>;
+    /** Cron expression (for type: schedule) */
+    schedule?: string;
+}
+/**
+ * Declares an external service provider that nodes can reference.
+ * The name is used as a local reference in node.provider fields.
+ */
+export interface ProviderRequirement {
+    /** Local reference name (used in node.provider) */
+    name: string;
+    /** Provider type (e.g., 'claude', 'linear', 'github') */
+    type: string;
+    /** Provider-specific configuration */
+    config?: Record<string, unknown>;
+}
+/**
+ * Workspace-level configuration for v2 workflows.
+ * Extensible with arbitrary keys beyond the known fields.
+ */
+export interface WorkflowConfig {
+    /** Maps project names to repository paths */
+    projectMapping?: Record<string, string>;
+    /** Extensible configuration */
+    [key: string]: unknown;
+}
+/**
+ * A single step within a v2 node's execution sequence.
+ * Steps execute in order and can reference outputs from earlier steps
+ * via {{ steps.<id>.output.<key> }} interpolation.
+ */
+export interface StepDefinition {
+    /** Unique step ID within the node */
+    id: string;
+    /** Provider action (e.g., 'spawn-session', 'tracker.create-comment') */
+    action: string;
+    /** Action parameters — supports {{ }} interpolation markers */
+    with?: Record<string, unknown>;
+    /** Optional condition for this step */
+    when?: string;
+    /** Declared outputs from this step */
+    output?: Record<string, PhaseOutputDeclaration>;
+}
+/**
+ * An action-based node in a v2 workflow. Nodes reference a provider and
+ * contain ordered multi-step sequences with template expression interpolation.
+ */
+export interface NodeDefinition {
+    /** Unique node name */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** Provider reference (must match a name in the providers section) */
+    provider?: string;
+    /** v1-style template reference (backwards compat) */
+    template?: string;
+    /** Multi-step execution sequence */
+    steps?: StepDefinition[];
+    /** Condition expression — node only executes when this evaluates to true */
+    when?: string;
+    /** Retry configuration */
+    retry?: TemplateRetryConfig;
+    /** Timeout configuration */
+    timeout?: TemplateTimeoutConfig;
+    /** Input dependencies on upstream outputs */
+    inputs?: Record<string, PhaseInputDeclaration>;
+    /** Structured outputs this node produces */
+    outputs?: Record<string, PhaseOutputDeclaration>;
+}
+/**
+ * v2 workflow definition with event-driven triggers, provider declarations,
+ * workspace config, and multi-step action nodes. Supports v1.1 phases and
+ * transitions alongside v2 nodes for backwards compatibility.
+ */
+export interface WorkflowDefinitionV2 {
+    apiVersion: 'v2';
+    kind: 'WorkflowDefinition';
+    metadata: {
+        name: string;
+        description?: string;
+    };
+    /** Event triggers that initiate workflow execution */
+    triggers?: WorkflowTriggerDefinition[];
+    /** External service providers that nodes can reference */
+    providers?: ProviderRequirement[];
+    /** Workspace-level configuration */
+    config?: WorkflowConfig;
+    /** v2 action-based nodes with multi-step sequences */
+    nodes?: NodeDefinition[];
+    /** v1.1 phase definitions (backwards compat) */
+    phases?: PhaseDefinition[];
+    /** Workflow graph edges: status-to-phase transitions */
+    transitions?: TransitionDefinition[];
+    /** Escalation ladder and circuit breaker configuration */
+    escalation?: EscalationConfig;
+    /** External gates that can pause workflow execution */
+    gates?: GateDefinition[];
+    /** Parallelism groups for concurrent phase execution */
+    parallelism?: ParallelismGroupDefinition[];
+    /** Branching blocks for conditional template selection */
+    branching?: BranchingDefinition[];
+}
+/**
+ * Union type for consumers that handle both v1.1 and v2 workflow definitions.
+ * Discriminated on the `apiVersion` field.
+ */
+export type AnyWorkflowDefinition = WorkflowDefinition | WorkflowDefinitionV2;
 /**
  * A declarative workflow definition. This is the primary document kind
  * introduced in schema v1.1, replacing the hard-coded workflow graph
@@ -574,14 +698,659 @@ export declare const WorkflowDefinitionSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
-/**
- * Validate a parsed YAML object as a WorkflowDefinition.
- * Throws ZodError with detailed messages on failure.
- *
- * After Zod schema validation succeeds, performs cross-validation to ensure:
- * - Parallelism group phase names reference defined phases
- * - Phase input `from` references point to valid phase.output declarations
- * - Warns (via console.warn) if maxConcurrent exceeds 10
- */
-export declare function validateWorkflowDefinition(data: unknown, filePath?: string): WorkflowDefinition;
+export declare const WorkflowTriggerDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        webhook: "webhook";
+        schedule: "schedule";
+        manual: "manual";
+    }>;
+    source: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    schedule: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ProviderRequirementSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const WorkflowConfigSchema: z.ZodObject<{
+    projectMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$loose>;
+export declare const StepDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodString;
+    with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    when: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            url: "url";
+            json: "json";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const NodeDefinitionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    template: z.ZodOptional<z.ZodString>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        action: z.ZodString;
+        with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        when: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    when: z.ZodOptional<z.ZodString>;
+    retry: z.ZodOptional<z.ZodObject<{
+        maxAttempts: z.ZodOptional<z.ZodNumber>;
+        ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            cycle: z.ZodNumber;
+            strategy: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    timeout: z.ZodOptional<z.ZodObject<{
+        duration: z.ZodString;
+        action: z.ZodEnum<{
+            fail: "fail";
+            escalate: "escalate";
+            skip: "skip";
+        }>;
+    }, z.core.$strip>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        from: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<{
+            string: "string";
+            boolean: "boolean";
+            url: "url";
+            json: "json";
+        }>;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const WorkflowDefinitionV2Schema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"v2">;
+    kind: z.ZodLiteral<"WorkflowDefinition">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            webhook: "webhook";
+            schedule: "schedule";
+            manual: "manual";
+        }>;
+        source: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        schedule: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    providers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    config: z.ZodOptional<z.ZodObject<{
+        projectMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$loose>>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            action: z.ZodString;
+            with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            when: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    boolean: "boolean";
+                    url: "url";
+                    json: "json";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        when: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    phases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        template: z.ZodString;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    transitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    escalation: z.ZodOptional<z.ZodObject<{
+        ladder: z.ZodArray<z.ZodObject<{
+            cycle: z.ZodNumber;
+            strategy: z.ZodString;
+        }, z.core.$strip>>;
+        circuitBreaker: z.ZodObject<{
+            maxSessionsPerIssue: z.ZodNumber;
+            maxSessionsPerPhase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    gates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            signal: "signal";
+            timer: "timer";
+            webhook: "webhook";
+        }>;
+        trigger: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    parallelism: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        phases: z.ZodArray<z.ZodString>;
+        strategy: z.ZodEnum<{
+            "fan-out": "fan-out";
+            "fan-in": "fan-in";
+            race: "race";
+        }>;
+        maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        waitForAll: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    branching: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        condition: z.ZodString;
+        then: z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        else: z.ZodOptional<z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Discriminated union schema that accepts both v1.1 and v2 workflow definitions.
+ * Dispatches to the correct schema based on the `apiVersion` field.
+ */
+export declare const AnyWorkflowDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    apiVersion: z.ZodLiteral<"v1.1">;
+    kind: z.ZodLiteral<"WorkflowDefinition">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    phases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        template: z.ZodString;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    transitions: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    escalation: z.ZodOptional<z.ZodObject<{
+        ladder: z.ZodArray<z.ZodObject<{
+            cycle: z.ZodNumber;
+            strategy: z.ZodString;
+        }, z.core.$strip>>;
+        circuitBreaker: z.ZodObject<{
+            maxSessionsPerIssue: z.ZodNumber;
+            maxSessionsPerPhase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    gates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            signal: "signal";
+            timer: "timer";
+            webhook: "webhook";
+        }>;
+        trigger: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    parallelism: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        phases: z.ZodArray<z.ZodString>;
+        strategy: z.ZodEnum<{
+            "fan-out": "fan-out";
+            "fan-in": "fan-in";
+            race: "race";
+        }>;
+        maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        waitForAll: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    branching: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        condition: z.ZodString;
+        then: z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        else: z.ZodOptional<z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodObject<{
+    apiVersion: z.ZodLiteral<"v2">;
+    kind: z.ZodLiteral<"WorkflowDefinition">;
+    metadata: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    triggers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            webhook: "webhook";
+            schedule: "schedule";
+            manual: "manual";
+        }>;
+        source: z.ZodOptional<z.ZodString>;
+        event: z.ZodOptional<z.ZodString>;
+        filter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        schedule: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    providers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    config: z.ZodOptional<z.ZodObject<{
+        projectMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$loose>>;
+    nodes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        template: z.ZodOptional<z.ZodString>;
+        steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            action: z.ZodString;
+            with: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            when: z.ZodOptional<z.ZodString>;
+            output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                type: z.ZodEnum<{
+                    string: "string";
+                    boolean: "boolean";
+                    url: "url";
+                    json: "json";
+                }>;
+                description: z.ZodOptional<z.ZodString>;
+                required: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>;
+        when: z.ZodOptional<z.ZodString>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    phases: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        template: z.ZodString;
+        variants: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        retry: z.ZodOptional<z.ZodObject<{
+            maxAttempts: z.ZodOptional<z.ZodNumber>;
+            ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                cycle: z.ZodNumber;
+                strategy: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        outputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<{
+                string: "string";
+                boolean: "boolean";
+                url: "url";
+                json: "json";
+            }>;
+            description: z.ZodOptional<z.ZodString>;
+            required: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    transitions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        condition: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    escalation: z.ZodOptional<z.ZodObject<{
+        ladder: z.ZodArray<z.ZodObject<{
+            cycle: z.ZodNumber;
+            strategy: z.ZodString;
+        }, z.core.$strip>>;
+        circuitBreaker: z.ZodObject<{
+            maxSessionsPerIssue: z.ZodNumber;
+            maxSessionsPerPhase: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    gates: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        type: z.ZodEnum<{
+            signal: "signal";
+            timer: "timer";
+            webhook: "webhook";
+        }>;
+        trigger: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        timeout: z.ZodOptional<z.ZodObject<{
+            duration: z.ZodString;
+            action: z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+                skip: "skip";
+            }>;
+        }, z.core.$strip>>;
+        appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    parallelism: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        phases: z.ZodArray<z.ZodString>;
+        strategy: z.ZodEnum<{
+            "fan-out": "fan-out";
+            "fan-in": "fan-in";
+            race: "race";
+        }>;
+        maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        waitForAll: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    branching: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        condition: z.ZodString;
+        then: z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        else: z.ZodOptional<z.ZodObject<{
+            template: z.ZodString;
+            retry: z.ZodOptional<z.ZodObject<{
+                maxAttempts: z.ZodOptional<z.ZodNumber>;
+                ladder: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    cycle: z.ZodNumber;
+                    strategy: z.ZodString;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            timeout: z.ZodOptional<z.ZodObject<{
+                duration: z.ZodString;
+                action: z.ZodEnum<{
+                    fail: "fail";
+                    escalate: "escalate";
+                    skip: "skip";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>], "apiVersion">;
+/**
+ * Validate a parsed YAML object as a WorkflowDefinition (v1.1).
+ * Throws ZodError with detailed messages on failure.
+ *
+ * After Zod schema validation succeeds, performs cross-validation to ensure:
+ * - Parallelism group phase names reference defined phases
+ * - Phase input `from` references point to valid phase.output declarations
+ * - Warns (via console.warn) if maxConcurrent exceeds 10
+ */
+export declare function validateWorkflowDefinition(data: unknown, filePath?: string): WorkflowDefinition;
+/**
+ * Validate a parsed YAML object as either a v1.1 or v2 WorkflowDefinition.
+ * Uses the `apiVersion` field to dispatch to the correct schema.
+ * Throws on invalid schema or cross-validation failure.
+ */
+export declare function validateAnyWorkflowDefinition(data: unknown, filePath?: string): AnyWorkflowDefinition;
+/**
+ * Perform cross-validation for v2 workflow definitions.
+ * Validates referential integrity for triggers, providers, nodes, and steps.
+ *
+ * Checks:
+ * - Node names must be unique
+ * - node.provider must reference a declared provider name
+ * - Step IDs must be unique within a node
+ * - {{ steps.<id>.output.<key> }} references must point to valid step IDs within the same node
+ * - {{ trigger.* }} references require at least one trigger to be declared
+ * - config.projectMapping values must be non-empty strings
+ * - when expressions must have balanced {{ }} brackets
+ */
+export declare function crossValidateWorkflowV2(workflow: WorkflowDefinitionV2, filePath?: string): void;
 //# sourceMappingURL=workflow-types.d.ts.map