@objectstack/spec 3.0.8 → 3.0.9

package/dist/automation/index.d.mts

@@ -1,3 +1,4 @@
-export { B as ApprovalActionSchema, z as ApprovalActionType, I as ApprovalProcess, G as ApprovalProcessSchema, J as ApprovalStep, D as ApprovalStepSchema, A as ApproverType, a9 as AuthField, a8 as AuthFieldSchema, ad as Authentication, ac as AuthenticationSchema, a7 as AuthenticationType, a6 as AuthenticationTypeSchema, av as ConflictResolution, au as ConflictResolutionSchema, an as Connector, C as ConnectorActionRefSchema, a5 as ConnectorCategory, a4 as ConnectorCategorySchema, ap as ConnectorInstance, ao as ConnectorInstanceSchema, aj as ConnectorOperation, ai as ConnectorOperationSchema, am as ConnectorSchema, al as ConnectorTrigger, ak as ConnectorTriggerSchema, a as CustomScriptActionSchema, az as DataDestinationConfig, ay as DataDestinationConfigSchema, ax as DataSourceConfig, aw as DataSourceConfigSchema, aB as DataSyncConfig, aA as DataSyncConfigSchema, a3 as ETL, Q as ETLDestination, O as ETLDestinationSchema, L as ETLEndpointType, K as ETLEndpointTypeSchema, _ as ETLPipeline, a2 as ETLPipelineRun, a1 as ETLPipelineRunSchema, Z as ETLPipelineSchema, a0 as ETLRunStatus, $ as ETLRunStatusSchema, N as ETLSource, M as ETLSourceSchema, Y as ETLSyncMode, X as ETLSyncModeSchema, V as ETLTransformation, U as ETLTransformationSchema, S as ETLTransformationType, R as ETLTransformationTypeSchema, E as EmailAlertActionSchema, F as FieldUpdateActionSchema, o as Flow, s as FlowEdge, t as FlowEdgeParsed, m as FlowEdgeSchema, q as FlowNode, j as FlowNodeAction, r as FlowNodeParsed, l as FlowNodeSchema, p as FlowParsed, n as FlowSchema, k as FlowVariableSchema, H as HttpCallActionSchema, ab as OAuth2Config, aa as OAuth2ConfigSchema, ah as OperationParameter, ag as OperationParameterSchema, af as OperationType, ae as OperationTypeSchema, P as PushNotificationActionSchema, aG as Sync, ar as SyncDirection, aq as SyncDirectionSchema, aF as SyncExecutionResult, aE as SyncExecutionResultSchema, aD as SyncExecutionStatus, aC as SyncExecutionStatusSchema, at as SyncMode, as as SyncModeSchema, T as TaskCreationActionSchema, h as TimeTrigger, e as TimeTriggerSchema, x as Webhook, y as WebhookReceiver, w as WebhookReceiverSchema, v as WebhookSchema, u as WebhookTriggerType, c as WorkflowAction, b as WorkflowActionSchema, g as WorkflowRule, f as WorkflowRuleSchema, W as WorkflowTriggerType, d as defineFlow } from '../index-DIaB52-2.mjs';
+export { o as ApprovalActionSchema, n as ApprovalActionType, r as ApprovalProcess, q as ApprovalProcessSchema, s as ApprovalStep, p as ApprovalStepSchema, A as ApproverType, Z as AuthField, Y as AuthFieldSchema, a1 as Authentication, a0 as AuthenticationSchema, X as AuthenticationType, V as AuthenticationTypeSchema, aU as BUILT_IN_BPMN_MAPPINGS, aR as BpmnDiagnostic, aQ as BpmnDiagnosticSchema, aH as BpmnElementMapping, aG as BpmnElementMappingSchema, aP as BpmnExportOptions, aO as BpmnExportOptionsSchema, aL as BpmnImportOptions, aK as BpmnImportOptionsSchema, aT as BpmnInteropResult, aS as BpmnInteropResultSchema, aJ as BpmnUnmappedStrategy, aI as BpmnUnmappedStrategySchema, aN as BpmnVersion, aM as BpmnVersionSchema, aj as ConflictResolution, ai as ConflictResolutionSchema, ab as Connector, C as ConnectorActionRefSchema, U as ConnectorCategory, S as ConnectorCategorySchema, ad as ConnectorInstance, ac as ConnectorInstanceSchema, a7 as ConnectorOperation, a6 as ConnectorOperationSchema, aa as ConnectorSchema, a9 as ConnectorTrigger, a8 as ConnectorTriggerSchema, a as CustomScriptActionSchema, an as DataDestinationConfig, am as DataDestinationConfigSchema, al as DataSourceConfig, ak as DataSourceConfigSchema, ap as DataSyncConfig, ao as DataSyncConfigSchema, R as ETL, y as ETLDestination, x as ETLDestinationSchema, u as ETLEndpointType, t as ETLEndpointTypeSchema, L as ETLPipeline, Q as ETLPipelineRun, O as ETLPipelineRunSchema, K as ETLPipelineSchema, N as ETLRunStatus, M as ETLRunStatusSchema, w as ETLSource, v as ETLSourceSchema, J as ETLSyncMode, I as ETLSyncModeSchema, G as ETLTransformation, D as ETLTransformationSchema, B as ETLTransformationType, z as ETLTransformationTypeSchema, E as EmailAlertActionSchema, F as FieldUpdateActionSchema, H as HttpCallActionSchema, aE as NodeExecutorDescriptor, aD as NodeExecutorDescriptorSchema, $ as OAuth2Config, _ as OAuth2ConfigSchema, a5 as OperationParameter, a4 as OperationParameterSchema, a3 as OperationType, a2 as OperationTypeSchema, P as PushNotificationActionSchema, au as Sync, af as SyncDirection, ae as SyncDirectionSchema, at as SyncExecutionResult, as as SyncExecutionResultSchema, ar as SyncExecutionStatus, aq as SyncExecutionStatusSchema, ah as SyncMode, ag as SyncModeSchema, T as TaskCreationActionSchema, g as TimeTrigger, d as TimeTriggerSchema, aF as WAIT_EXECUTOR_DESCRIPTOR, aw as WaitEventType, av as WaitEventTypeSchema, aC as WaitExecutorConfig, aB as WaitExecutorConfigSchema, ay as WaitResumePayload, ax as WaitResumePayloadSchema, aA as WaitTimeoutBehavior, az as WaitTimeoutBehaviorSchema, l as Webhook, m as WebhookReceiver, k as WebhookReceiverSchema, j as WebhookSchema, h as WebhookTriggerType, c as WorkflowAction, b as WorkflowActionSchema, f as WorkflowRule, e as WorkflowRuleSchema, W as WorkflowTriggerType } from '../index-RL3hxi-b.mjs';
+export { C as Checkpoint, a as CheckpointParsed, b as CheckpointSchema, c as ConcurrencyPolicy, e as ConcurrencyPolicyParsed, f as ConcurrencyPolicySchema, E as ExecutionError, g as ExecutionErrorParsed, h as ExecutionErrorSchema, i as ExecutionErrorSeverity, j as ExecutionLog, k as ExecutionLogParsed, l as ExecutionLogSchema, m as ExecutionStatus, n as ExecutionStepLog, o as ExecutionStepLogParsed, p as ExecutionStepLogSchema, F as Flow, q as FlowEdge, r as FlowEdgeParsed, s as FlowEdgeSchema, t as FlowNode, u as FlowNodeAction, v as FlowNodeParsed, w as FlowNodeSchema, x as FlowParsed, y as FlowSchema, z as FlowVariableSchema, A as FlowVersionHistory, B as FlowVersionHistoryParsed, D as FlowVersionHistorySchema, S as ScheduleState, G as ScheduleStateParsed, H as ScheduleStateSchema, d as defineFlow } from '../execution.zod-CNIVLUlM.mjs';
 export { A as ActionRef, a as ActionRefSchema, E as EventSchema, G as GuardRefSchema, b as StateMachineConfig, c as StateMachineSchema, S as StateNodeConfig, d as StateNodeSchema, T as Transition, e as TransitionSchema } from '../state-machine.zod-DoC0JvQb.mjs';
 import 'zod';

package/dist/automation/index.d.ts

@@ -1,3 +1,4 @@
-export { B as ApprovalActionSchema, z as ApprovalActionType, I as ApprovalProcess, G as ApprovalProcessSchema, J as ApprovalStep, D as ApprovalStepSchema, A as ApproverType, a9 as AuthField, a8 as AuthFieldSchema, ad as Authentication, ac as AuthenticationSchema, a7 as AuthenticationType, a6 as AuthenticationTypeSchema, av as ConflictResolution, au as ConflictResolutionSchema, an as Connector, C as ConnectorActionRefSchema, a5 as ConnectorCategory, a4 as ConnectorCategorySchema, ap as ConnectorInstance, ao as ConnectorInstanceSchema, aj as ConnectorOperation, ai as ConnectorOperationSchema, am as ConnectorSchema, al as ConnectorTrigger, ak as ConnectorTriggerSchema, a as CustomScriptActionSchema, az as DataDestinationConfig, ay as DataDestinationConfigSchema, ax as DataSourceConfig, aw as DataSourceConfigSchema, aB as DataSyncConfig, aA as DataSyncConfigSchema, a3 as ETL, Q as ETLDestination, O as ETLDestinationSchema, L as ETLEndpointType, K as ETLEndpointTypeSchema, _ as ETLPipeline, a2 as ETLPipelineRun, a1 as ETLPipelineRunSchema, Z as ETLPipelineSchema, a0 as ETLRunStatus, $ as ETLRunStatusSchema, N as ETLSource, M as ETLSourceSchema, Y as ETLSyncMode, X as ETLSyncModeSchema, V as ETLTransformation, U as ETLTransformationSchema, S as ETLTransformationType, R as ETLTransformationTypeSchema, E as EmailAlertActionSchema, F as FieldUpdateActionSchema, o as Flow, s as FlowEdge, t as FlowEdgeParsed, m as FlowEdgeSchema, q as FlowNode, j as FlowNodeAction, r as FlowNodeParsed, l as FlowNodeSchema, p as FlowParsed, n as FlowSchema, k as FlowVariableSchema, H as HttpCallActionSchema, ab as OAuth2Config, aa as OAuth2ConfigSchema, ah as OperationParameter, ag as OperationParameterSchema, af as OperationType, ae as OperationTypeSchema, P as PushNotificationActionSchema, aG as Sync, ar as SyncDirection, aq as SyncDirectionSchema, aF as SyncExecutionResult, aE as SyncExecutionResultSchema, aD as SyncExecutionStatus, aC as SyncExecutionStatusSchema, at as SyncMode, as as SyncModeSchema, T as TaskCreationActionSchema, h as TimeTrigger, e as TimeTriggerSchema, x as Webhook, y as WebhookReceiver, w as WebhookReceiverSchema, v as WebhookSchema, u as WebhookTriggerType, c as WorkflowAction, b as WorkflowActionSchema, g as WorkflowRule, f as WorkflowRuleSchema, W as WorkflowTriggerType, d as defineFlow } from '../index-Clv7cLYS.js';
+export { o as ApprovalActionSchema, n as ApprovalActionType, r as ApprovalProcess, q as ApprovalProcessSchema, s as ApprovalStep, p as ApprovalStepSchema, A as ApproverType, Z as AuthField, Y as AuthFieldSchema, a1 as Authentication, a0 as AuthenticationSchema, X as AuthenticationType, V as AuthenticationTypeSchema, aU as BUILT_IN_BPMN_MAPPINGS, aR as BpmnDiagnostic, aQ as BpmnDiagnosticSchema, aH as BpmnElementMapping, aG as BpmnElementMappingSchema, aP as BpmnExportOptions, aO as BpmnExportOptionsSchema, aL as BpmnImportOptions, aK as BpmnImportOptionsSchema, aT as BpmnInteropResult, aS as BpmnInteropResultSchema, aJ as BpmnUnmappedStrategy, aI as BpmnUnmappedStrategySchema, aN as BpmnVersion, aM as BpmnVersionSchema, aj as ConflictResolution, ai as ConflictResolutionSchema, ab as Connector, C as ConnectorActionRefSchema, U as ConnectorCategory, S as ConnectorCategorySchema, ad as ConnectorInstance, ac as ConnectorInstanceSchema, a7 as ConnectorOperation, a6 as ConnectorOperationSchema, aa as ConnectorSchema, a9 as ConnectorTrigger, a8 as ConnectorTriggerSchema, a as CustomScriptActionSchema, an as DataDestinationConfig, am as DataDestinationConfigSchema, al as DataSourceConfig, ak as DataSourceConfigSchema, ap as DataSyncConfig, ao as DataSyncConfigSchema, R as ETL, y as ETLDestination, x as ETLDestinationSchema, u as ETLEndpointType, t as ETLEndpointTypeSchema, L as ETLPipeline, Q as ETLPipelineRun, O as ETLPipelineRunSchema, K as ETLPipelineSchema, N as ETLRunStatus, M as ETLRunStatusSchema, w as ETLSource, v as ETLSourceSchema, J as ETLSyncMode, I as ETLSyncModeSchema, G as ETLTransformation, D as ETLTransformationSchema, B as ETLTransformationType, z as ETLTransformationTypeSchema, E as EmailAlertActionSchema, F as FieldUpdateActionSchema, H as HttpCallActionSchema, aE as NodeExecutorDescriptor, aD as NodeExecutorDescriptorSchema, $ as OAuth2Config, _ as OAuth2ConfigSchema, a5 as OperationParameter, a4 as OperationParameterSchema, a3 as OperationType, a2 as OperationTypeSchema, P as PushNotificationActionSchema, au as Sync, af as SyncDirection, ae as SyncDirectionSchema, at as SyncExecutionResult, as as SyncExecutionResultSchema, ar as SyncExecutionStatus, aq as SyncExecutionStatusSchema, ah as SyncMode, ag as SyncModeSchema, T as TaskCreationActionSchema, g as TimeTrigger, d as TimeTriggerSchema, aF as WAIT_EXECUTOR_DESCRIPTOR, aw as WaitEventType, av as WaitEventTypeSchema, aC as WaitExecutorConfig, aB as WaitExecutorConfigSchema, ay as WaitResumePayload, ax as WaitResumePayloadSchema, aA as WaitTimeoutBehavior, az as WaitTimeoutBehaviorSchema, l as Webhook, m as WebhookReceiver, k as WebhookReceiverSchema, j as WebhookSchema, h as WebhookTriggerType, c as WorkflowAction, b as WorkflowActionSchema, f as WorkflowRule, e as WorkflowRuleSchema, W as WorkflowTriggerType } from '../index-C6lkTV3q.js';
+export { C as Checkpoint, a as CheckpointParsed, b as CheckpointSchema, c as ConcurrencyPolicy, e as ConcurrencyPolicyParsed, f as ConcurrencyPolicySchema, E as ExecutionError, g as ExecutionErrorParsed, h as ExecutionErrorSchema, i as ExecutionErrorSeverity, j as ExecutionLog, k as ExecutionLogParsed, l as ExecutionLogSchema, m as ExecutionStatus, n as ExecutionStepLog, o as ExecutionStepLogParsed, p as ExecutionStepLogSchema, F as Flow, q as FlowEdge, r as FlowEdgeParsed, s as FlowEdgeSchema, t as FlowNode, u as FlowNodeAction, v as FlowNodeParsed, w as FlowNodeSchema, x as FlowParsed, y as FlowSchema, z as FlowVariableSchema, A as FlowVersionHistory, B as FlowVersionHistoryParsed, D as FlowVersionHistorySchema, S as ScheduleState, G as ScheduleStateParsed, H as ScheduleStateSchema, d as defineFlow } from '../execution.zod-CNIVLUlM.js';
 export { A as ActionRef, a as ActionRefSchema, E as EventSchema, G as GuardRefSchema, b as StateMachineConfig, c as StateMachineSchema, S as StateNodeConfig, d as StateNodeSchema, T as Transition, e as TransitionSchema } from '../state-machine.zod-DoC0JvQb.js';
 import 'zod';

package/dist/automation/index.js

@@ -160,8 +160,14 @@ var FlowNodeAction = zod.z.enum([
   // Delay/Sleep
   "subflow",
   // Call another flow
-  "connector_action"
+  "connector_action",
   // Zapier-style integration action
+  "parallel_gateway",
+  // BPMN Parallel Gateway — AND-split (all outgoing branches execute concurrently)
+  "join_gateway",
+  // BPMN Join Gateway — AND-join (waits for all incoming branches to complete)
+  "boundary_event"
+  // BPMN Boundary Event — attached to a host node for timer/error/signal interrupts
 ]);
 var FlowVariableSchema = zod.z.object({
   name: zod.z.string().describe("Variable name"),
@@ -185,7 +191,56 @@ var FlowNodeSchema = zod.z.object({
     input: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Mapped inputs for the action")
   }).optional(),
   /** UI Position (for the canvas) */
-  position: zod.z.object({ x: zod.z.number(), y: zod.z.number() }).optional()
+  position: zod.z.object({ x: zod.z.number(), y: zod.z.number() }).optional(),
+  /** Node-level execution timeout */
+  timeoutMs: zod.z.number().int().min(0).optional().describe("Maximum execution time for this node in milliseconds"),
+  /** Node input schema declaration for Studio form generation and runtime validation */
+  inputSchema: zod.z.record(zod.z.string(), zod.z.object({
+    type: zod.z.enum(["string", "number", "boolean", "object", "array"]).describe("Parameter type"),
+    required: zod.z.boolean().default(false).describe("Whether the parameter is required"),
+    description: zod.z.string().optional().describe("Parameter description")
+  })).optional().describe("Input parameter schema for this node"),
+  /** Node output schema declaration */
+  outputSchema: zod.z.record(zod.z.string(), zod.z.object({
+    type: zod.z.enum(["string", "number", "boolean", "object", "array"]).describe("Output type"),
+    description: zod.z.string().optional().describe("Output description")
+  })).optional().describe("Output schema declaration for this node"),
+  /**
+   * Wait Event Configuration (for 'wait' nodes)
+   * Defines what external event or condition should resume the paused execution.
+   * Industry alignment: BPMN Intermediate Catch Events, Temporal Signals.
+   */
+  waitEventConfig: zod.z.object({
+    /** Type of event to wait for */
+    eventType: zod.z.enum(["timer", "signal", "webhook", "manual", "condition"]).describe("What kind of event resumes the execution"),
+    /** Duration to wait (ISO 8601 duration or milliseconds) — for timer events */
+    timerDuration: zod.z.string().optional().describe('ISO 8601 duration (e.g., "PT1H") or wait time for timer events'),
+    /** Signal name to listen for — for signal/webhook events */
+    signalName: zod.z.string().optional().describe("Named signal or webhook event to wait for"),
+    /** Timeout before auto-failing or continuing — optional guard */
+    timeoutMs: zod.z.number().int().min(0).optional().describe("Maximum wait time before timeout (ms)"),
+    /** Action to take on timeout */
+    onTimeout: zod.z.enum(["fail", "continue"]).default("fail").describe("Behavior when the wait times out")
+  }).optional().describe("Configuration for wait node event resumption"),
+  /**
+   * Boundary Event Configuration (for 'boundary_event' nodes)
+   * Attaches an event handler to a host activity node (BPMN Boundary Event pattern).
+   * Industry alignment: BPMN Boundary Error/Timer/Signal Events.
+   */
+  boundaryConfig: zod.z.object({
+    /** ID of the host node this boundary event is attached to */
+    attachedToNodeId: zod.z.string().describe("Host node ID this boundary event monitors"),
+    /** Type of boundary event */
+    eventType: zod.z.enum(["error", "timer", "signal", "cancel"]).describe("Boundary event trigger type"),
+    /** Whether the boundary event interrupts the host activity */
+    interrupting: zod.z.boolean().default(true).describe("If true, the host activity is cancelled when this event fires"),
+    /** Error code filter — only for error boundary events */
+    errorCode: zod.z.string().optional().describe("Specific error code to catch (empty = catch all errors)"),
+    /** Timer duration — only for timer boundary events */
+    timerDuration: zod.z.string().optional().describe("ISO 8601 duration for timer boundary events"),
+    /** Signal name — only for signal boundary events */
+    signalName: zod.z.string().optional().describe("Named signal to catch")
+  }).optional().describe("Configuration for boundary events attached to host nodes")
 });
 var FlowEdgeSchema = zod.z.object({
   id: zod.z.string().describe("Edge unique ID"),
@@ -193,8 +248,14 @@ var FlowEdgeSchema = zod.z.object({
   target: zod.z.string().describe("Target Node ID"),
   /** Condition for this path (only for decision/branch nodes) */
   condition: zod.z.string().optional().describe("Expression returning boolean used for branching"),
-  type: zod.z.enum(["default", "fault"]).default("default").describe("Connection type: Standard (Success) or Fault (Error) path"),
-  label: zod.z.string().optional().describe("Label on the connector")
+  type: zod.z.enum(["default", "fault", "conditional"]).default("default").describe("Connection type: default (normal flow), fault (error path), or conditional (expression-guarded)"),
+  label: zod.z.string().optional().describe("Label on the connector"),
+  /**
+   * Default Sequence Flow marker (BPMN Default Flow semantics).
+   * When true, this edge is taken when no sibling conditional edges match.
+   * Only meaningful on outgoing edges of decision/gateway nodes.
+   */
+  isDefault: zod.z.boolean().default(false).describe("Marks this edge as the default path when no other conditions match")
 });
 var FlowSchema = zod.z.object({
   /** Identity */
@@ -220,12 +281,159 @@ var FlowSchema = zod.z.object({
     strategy: zod.z.enum(["fail", "retry", "continue"]).default("fail").describe("How to handle node execution errors"),
     maxRetries: zod.z.number().int().min(0).max(10).default(0).describe("Number of retry attempts (only for retry strategy)"),
     retryDelayMs: zod.z.number().int().min(0).default(1e3).describe("Delay between retries in milliseconds"),
+    backoffMultiplier: zod.z.number().min(1).default(1).describe("Multiplier for exponential backoff between retries"),
+    maxRetryDelayMs: zod.z.number().int().min(0).default(3e4).describe("Maximum delay between retries in milliseconds"),
+    jitter: zod.z.boolean().default(false).describe("Add random jitter to retry delay to avoid thundering herd"),
     fallbackNodeId: zod.z.string().optional().describe("Node ID to jump to on unrecoverable error")
   }).optional().describe("Flow-level error handling configuration")
 });
 function defineFlow(config) {
   return FlowSchema.parse(config);
 }
+var FlowVersionHistorySchema = zod.z.object({
+  flowName: zod.z.string().describe("Flow machine name"),
+  version: zod.z.number().int().min(1).describe("Version number"),
+  definition: FlowSchema.describe("Complete flow definition snapshot"),
+  createdAt: zod.z.string().datetime().describe("When this version was created"),
+  createdBy: zod.z.string().optional().describe("User who created this version"),
+  changeNote: zod.z.string().optional().describe("Description of what changed in this version")
+});
+var ExecutionStatus = zod.z.enum([
+  "pending",
+  // Queued, not yet started
+  "running",
+  // Currently executing
+  "paused",
+  // Paused at a wait/checkpoint node
+  "completed",
+  // Successfully finished
+  "failed",
+  // Terminated with error
+  "cancelled",
+  // Manually cancelled
+  "timed_out",
+  // Exceeded max execution time
+  "retrying"
+  // Failed and retrying
+]);
+var ExecutionStepLogSchema = zod.z.object({
+  nodeId: zod.z.string().describe("Node ID that was executed"),
+  nodeType: zod.z.string().describe('Node action type (e.g., "decision", "http_request")'),
+  nodeLabel: zod.z.string().optional().describe("Human-readable node label"),
+  status: zod.z.enum(["success", "failure", "skipped"]).describe("Step execution result"),
+  startedAt: zod.z.string().datetime().describe("When the step started"),
+  completedAt: zod.z.string().datetime().optional().describe("When the step completed"),
+  durationMs: zod.z.number().int().min(0).optional().describe("Step execution duration in milliseconds"),
+  input: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Input data passed to the node"),
+  output: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Output data produced by the node"),
+  error: zod.z.object({
+    code: zod.z.string().describe("Error code"),
+    message: zod.z.string().describe("Error message"),
+    stack: zod.z.string().optional().describe("Stack trace")
+  }).optional().describe("Error details if step failed"),
+  retryAttempt: zod.z.number().int().min(0).optional().describe("Retry attempt number (0 = first try)")
+});
+var ExecutionLogSchema = zod.z.object({
+  /** Unique execution ID */
+  id: zod.z.string().describe("Execution instance ID"),
+  /** Flow reference */
+  flowName: zod.z.string().describe("Machine name of the executed flow"),
+  flowVersion: zod.z.number().int().optional().describe("Version of the flow that was executed"),
+  /** Execution status */
+  status: ExecutionStatus.describe("Current execution status"),
+  /** Trigger context */
+  trigger: zod.z.object({
+    type: zod.z.string().describe('Trigger type (e.g., "record_change", "schedule", "api", "manual")'),
+    recordId: zod.z.string().optional().describe("Triggering record ID"),
+    object: zod.z.string().optional().describe("Triggering object name"),
+    userId: zod.z.string().optional().describe("User who triggered the execution"),
+    metadata: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Additional trigger context")
+  }).describe("What triggered this execution"),
+  /** Step-by-step execution history */
+  steps: zod.z.array(ExecutionStepLogSchema).describe("Ordered list of executed steps"),
+  /** Execution variables snapshot */
+  variables: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Final state of flow variables"),
+  /** Timing */
+  startedAt: zod.z.string().datetime().describe("Execution start timestamp"),
+  completedAt: zod.z.string().datetime().optional().describe("Execution completion timestamp"),
+  durationMs: zod.z.number().int().min(0).optional().describe("Total execution duration in milliseconds"),
+  /** Context */
+  runAs: zod.z.enum(["system", "user"]).optional().describe("Execution context identity"),
+  tenantId: zod.z.string().optional().describe("Tenant ID for multi-tenant isolation")
+});
+var ExecutionErrorSeverity = zod.z.enum([
+  "warning",
+  // Non-fatal issue (e.g., deprecated node type)
+  "error",
+  // Node-level failure (may be retried)
+  "critical"
+  // Flow-level failure (execution terminated)
+]);
+var ExecutionErrorSchema = zod.z.object({
+  id: zod.z.string().describe("Error record ID"),
+  executionId: zod.z.string().describe("Parent execution ID"),
+  nodeId: zod.z.string().optional().describe("Node where the error occurred"),
+  severity: ExecutionErrorSeverity.describe("Error severity level"),
+  code: zod.z.string().describe("Machine-readable error code"),
+  message: zod.z.string().describe("Human-readable error message"),
+  stack: zod.z.string().optional().describe("Stack trace for debugging"),
+  context: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Additional diagnostic context (input data, config snapshot)"),
+  timestamp: zod.z.string().datetime().describe("When the error occurred"),
+  retryable: zod.z.boolean().default(false).describe("Whether this error can be retried"),
+  resolvedAt: zod.z.string().datetime().optional().describe("When the error was resolved (e.g., after successful retry)")
+});
+var CheckpointSchema = zod.z.object({
+  /** Unique checkpoint ID */
+  id: zod.z.string().describe("Checkpoint ID"),
+  /** Execution reference */
+  executionId: zod.z.string().describe("Parent execution ID"),
+  flowName: zod.z.string().describe("Flow machine name"),
+  /** State snapshot */
+  currentNodeId: zod.z.string().describe("Node ID where execution is paused"),
+  variables: zod.z.record(zod.z.string(), zod.z.unknown()).describe("Flow variable state at checkpoint"),
+  completedNodeIds: zod.z.array(zod.z.string()).describe("List of node IDs already executed"),
+  /** Timing */
+  createdAt: zod.z.string().datetime().describe("Checkpoint creation timestamp"),
+  expiresAt: zod.z.string().datetime().optional().describe("Checkpoint expiration (auto-cleanup)"),
+  /** Reason */
+  reason: zod.z.enum(["wait", "screen_input", "approval", "error", "manual_pause", "parallel_join", "boundary_event"]).describe("Why the execution was checkpointed")
+});
+var ConcurrencyPolicySchema = zod.z.object({
+  /** Maximum concurrent executions of this flow */
+  maxConcurrent: zod.z.number().int().min(1).default(1).describe("Maximum number of concurrent executions allowed"),
+  /** What to do when max concurrency is reached */
+  onConflict: zod.z.enum(["queue", "reject", "cancel_existing"]).default("queue").describe("queue = enqueue for later, reject = fail immediately, cancel_existing = stop running instance"),
+  /** Lock scope for concurrency */
+  lockScope: zod.z.enum(["global", "per_record", "per_user"]).default("global").describe("Scope of the concurrency lock"),
+  /** Queue timeout (only when onConflict is "queue") */
+  queueTimeoutMs: zod.z.number().int().min(0).optional().describe("Maximum time to wait in queue before timing out (ms)")
+});
+var ScheduleStateSchema = zod.z.object({
+  /** Unique schedule ID */
+  id: zod.z.string().describe("Schedule instance ID"),
+  /** Flow reference */
+  flowName: zod.z.string().describe("Flow machine name"),
+  /** Schedule configuration */
+  cronExpression: zod.z.string().describe('Cron expression (e.g., "0 9 * * MON-FRI")'),
+  timezone: zod.z.string().default("UTC").describe("IANA timezone for cron evaluation"),
+  /** Runtime state */
+  status: zod.z.enum(["active", "paused", "disabled", "expired"]).default("active").describe("Current schedule status"),
+  nextRunAt: zod.z.string().datetime().optional().describe("Next scheduled execution timestamp"),
+  lastRunAt: zod.z.string().datetime().optional().describe("Last execution timestamp"),
+  lastExecutionId: zod.z.string().optional().describe("Execution ID of the last run"),
+  lastRunStatus: ExecutionStatus.optional().describe("Status of the last run"),
+  /** Execution tracking */
+  totalRuns: zod.z.number().int().min(0).default(0).describe("Total number of executions"),
+  consecutiveFailures: zod.z.number().int().min(0).default(0).describe("Consecutive failed executions"),
+  /** Bounds */
+  startDate: zod.z.string().datetime().optional().describe("Schedule effective start date"),
+  endDate: zod.z.string().datetime().optional().describe("Schedule expiration date"),
+  maxRuns: zod.z.number().int().min(1).optional().describe("Maximum total executions before auto-disable"),
+  /** Metadata */
+  createdAt: zod.z.string().datetime().describe("Schedule creation timestamp"),
+  updatedAt: zod.z.string().datetime().optional().describe("Last update timestamp"),
+  createdBy: zod.z.string().optional().describe("User who created the schedule")
+});
 var WebhookTriggerType = zod.z.enum([
   "create",
   "update",
@@ -1520,6 +1728,179 @@ var StateMachineSchema = zod.z.object({
   /** Global Listeners */
   on: zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), TransitionSchema, zod.z.array(TransitionSchema)])).optional()
 });
+var WaitEventTypeSchema = zod.z.enum([
+  "timer",
+  // Resume after duration/datetime
+  "signal",
+  // Resume on named signal dispatch
+  "webhook",
+  // Resume on incoming webhook call
+  "manual",
+  // Resume by manual operator action
+  "condition"
+  // Resume when a data condition is met (polling)
+]).describe("Wait event type determining how a paused flow is resumed");
+var WaitResumePayloadSchema = zod.z.object({
+  /** The execution id of the paused flow */
+  executionId: zod.z.string().describe("Execution ID of the paused flow"),
+  /** The checkpoint id being resumed */
+  checkpointId: zod.z.string().describe("Checkpoint ID to resume from"),
+  /** The node id of the wait node being resumed */
+  nodeId: zod.z.string().describe("Wait node ID being resumed"),
+  /** The event type that triggered the resume */
+  eventType: WaitEventTypeSchema.describe("Event type that triggered resume"),
+  /** Signal name (for signal events) */
+  signalName: zod.z.string().optional().describe("Signal name (when eventType is signal)"),
+  /** Webhook payload data (for webhook events) */
+  webhookPayload: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Webhook request payload (when eventType is webhook)"),
+  /** Who/what triggered the resume */
+  resumedBy: zod.z.string().optional().describe("User ID or system identifier that triggered resume"),
+  /** Timestamp of the resume event */
+  resumedAt: zod.z.string().datetime().describe("ISO 8601 timestamp of the resume event"),
+  /** Additional variables to merge into flow context on resume */
+  variables: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Variables to merge into flow context upon resume")
+}).describe("Payload for resuming a paused wait node");
+var WaitTimeoutBehaviorSchema = zod.z.enum([
+  "fail",
+  // Mark execution as failed
+  "continue",
+  // Continue to next node (skip wait)
+  "fallback"
+  // Execute a fallback edge
+]).describe("Behavior when a wait node exceeds its timeout");
+var WaitExecutorConfigSchema = zod.z.object({
+  /** Default timeout for wait nodes without explicit timeout (ms) */
+  defaultTimeoutMs: zod.z.number().int().min(0).default(864e5).describe("Default timeout in ms (default: 24 hours)"),
+  /** Default timeout behavior */
+  defaultTimeoutBehavior: WaitTimeoutBehaviorSchema.default("fail").describe("Default behavior when wait timeout is exceeded"),
+  /** Polling interval for condition-based waits (ms) */
+  conditionPollIntervalMs: zod.z.number().int().min(1e3).default(3e4).describe("Polling interval for condition waits in ms (default: 30s)"),
+  /** Maximum polling attempts for condition waits (0 = unlimited until timeout) */
+  conditionMaxPolls: zod.z.number().int().min(0).default(0).describe("Max polling attempts for condition waits (0 = unlimited)"),
+  /** Webhook endpoint URL pattern (runtime fills in execution/node ids) */
+  webhookUrlPattern: zod.z.string().default("/api/v1/automation/resume/{executionId}/{nodeId}").describe("URL pattern for webhook resume endpoints"),
+  /** Whether to persist checkpoints to durable storage */
+  persistCheckpoints: zod.z.boolean().default(true).describe("Persist wait checkpoints to durable storage"),
+  /** Maximum concurrent paused executions (0 = unlimited) */
+  maxPausedExecutions: zod.z.number().int().min(0).default(0).describe("Max concurrent paused executions (0 = unlimited)")
+}).describe("Wait node executor plugin configuration");
+var NodeExecutorDescriptorSchema = zod.z.object({
+  /** Unique executor identifier */
+  id: zod.z.string().describe("Unique executor plugin identifier"),
+  /** Human-readable name */
+  name: zod.z.string().describe("Display name"),
+  /** The FlowNodeAction types this executor handles */
+  nodeTypes: zod.z.array(zod.z.string()).min(1).describe("FlowNodeAction types this executor handles"),
+  /** Executor plugin version (semver) */
+  version: zod.z.string().describe("Plugin version (semver)"),
+  /** Description of the executor */
+  description: zod.z.string().optional().describe("Executor description"),
+  /** Whether this executor supports async pause/resume */
+  supportsPause: zod.z.boolean().default(false).describe("Whether the executor supports async pause/resume"),
+  /** Whether this executor supports cancellation mid-execution */
+  supportsCancellation: zod.z.boolean().default(false).describe("Whether the executor supports mid-execution cancellation"),
+  /** Whether this executor supports retry on failure */
+  supportsRetry: zod.z.boolean().default(true).describe("Whether the executor supports retry on failure"),
+  /** Executor-specific configuration schema (JSON Schema reference) */
+  configSchemaRef: zod.z.string().optional().describe("JSON Schema $ref for executor-specific config")
+}).describe("Node executor plugin descriptor");
+var WAIT_EXECUTOR_DESCRIPTOR = {
+  id: "objectstack:wait-executor",
+  name: "Wait Node Executor",
+  nodeTypes: ["wait"],
+  version: "1.0.0",
+  description: "Pauses flow execution and resumes on timer, signal, webhook, manual action, or condition events.",
+  supportsPause: true,
+  supportsCancellation: true,
+  supportsRetry: true
+};
+var BpmnElementMappingSchema = zod.z.object({
+  /** BPMN XML element type (e.g., "bpmn:parallelGateway", "bpmn:serviceTask") */
+  bpmnType: zod.z.string().describe('BPMN XML element type (e.g., "bpmn:parallelGateway")'),
+  /** Corresponding ObjectStack FlowNodeAction */
+  flowNodeAction: zod.z.string().describe("ObjectStack FlowNodeAction value"),
+  /** Whether this mapping is bidirectional (supports both import and export) */
+  bidirectional: zod.z.boolean().default(true).describe("Whether the mapping supports both import and export"),
+  /** Notes about mapping limitations or special handling */
+  notes: zod.z.string().optional().describe("Notes about mapping limitations")
+}).describe("Mapping between BPMN XML element and ObjectStack FlowNodeAction");
+var BpmnUnmappedStrategySchema = zod.z.enum([
+  "skip",
+  // Skip unmapped elements silently
+  "warn",
+  // Import with warnings
+  "error",
+  // Fail on unmapped elements
+  "comment"
+  // Import as annotation/comment nodes
+]).describe("Strategy for unmapped BPMN elements during import");
+var BpmnImportOptionsSchema = zod.z.object({
+  /** Strategy for unmapped BPMN elements */
+  unmappedStrategy: BpmnUnmappedStrategySchema.default("warn").describe("How to handle unmapped BPMN elements"),
+  /** Custom element mappings (override or extend built-in mappings) */
+  customMappings: zod.z.array(BpmnElementMappingSchema).optional().describe("Custom element mappings to override or extend defaults"),
+  /** Whether to import BPMN DI (diagram interchange) layout positions */
+  importLayout: zod.z.boolean().default(true).describe("Import BPMN DI layout positions into canvas node coordinates"),
+  /** Whether to import BPMN documentation as node descriptions */
+  importDocumentation: zod.z.boolean().default(true).describe("Import BPMN documentation elements as node descriptions"),
+  /** Target flow name (if not derived from BPMN process name) */
+  flowName: zod.z.string().optional().describe("Override flow name (defaults to BPMN process name)"),
+  /** Whether to validate the imported flow against ObjectStack schema */
+  validateAfterImport: zod.z.boolean().default(true).describe("Validate imported flow against FlowSchema after import")
+}).describe("Options for importing BPMN 2.0 XML into an ObjectStack flow");
+var BpmnVersionSchema = zod.z.enum([
+  "2.0",
+  // BPMN 2.0 (most common, default)
+  "2.0.2"
+  // BPMN 2.0.2 (latest revision)
+]).describe("BPMN specification version for export");
+var BpmnExportOptionsSchema = zod.z.object({
+  /** Target BPMN version */
+  version: BpmnVersionSchema.default("2.0").describe("Target BPMN specification version"),
+  /** Whether to include BPMN DI (diagram interchange) layout data */
+  includeLayout: zod.z.boolean().default(true).describe("Include BPMN DI layout data from canvas positions"),
+  /** Whether to include ObjectStack-specific extensions as BPMN extension elements */
+  includeExtensions: zod.z.boolean().default(false).describe("Include ObjectStack extensions in BPMN extensionElements"),
+  /** Custom element mappings (override built-in for export) */
+  customMappings: zod.z.array(BpmnElementMappingSchema).optional().describe("Custom element mappings for export"),
+  /** Whether to pretty-print the XML output */
+  prettyPrint: zod.z.boolean().default(true).describe("Pretty-print XML output with indentation"),
+  /** XML namespace prefix for BPMN elements */
+  namespacePrefix: zod.z.string().default("bpmn").describe("XML namespace prefix for BPMN elements")
+}).describe("Options for exporting an ObjectStack flow as BPMN 2.0 XML");
+var BpmnDiagnosticSchema = zod.z.object({
+  /** Severity level */
+  severity: zod.z.enum(["info", "warning", "error"]).describe("Diagnostic severity"),
+  /** Human-readable message */
+  message: zod.z.string().describe("Diagnostic message"),
+  /** BPMN element ID (if applicable) */
+  bpmnElementId: zod.z.string().optional().describe("BPMN element ID related to this diagnostic"),
+  /** ObjectStack node ID (if applicable) */
+  nodeId: zod.z.string().optional().describe("ObjectStack node ID related to this diagnostic")
+}).describe("Diagnostic message from BPMN import/export");
+var BpmnInteropResultSchema = zod.z.object({
+  /** Whether the operation completed successfully */
+  success: zod.z.boolean().describe("Whether the operation completed successfully"),
+  /** Diagnostic messages (warnings, errors, info) */
+  diagnostics: zod.z.array(BpmnDiagnosticSchema).default([]).describe("Diagnostic messages from the operation"),
+  /** Number of elements successfully mapped */
+  mappedCount: zod.z.number().int().min(0).default(0).describe("Number of elements successfully mapped"),
+  /** Number of elements skipped or unmapped */
+  unmappedCount: zod.z.number().int().min(0).default(0).describe("Number of elements that could not be mapped")
+}).describe("Result of a BPMN import/export operation");
+var BUILT_IN_BPMN_MAPPINGS = [
+  { bpmnType: "bpmn:startEvent", flowNodeAction: "start", bidirectional: true },
+  { bpmnType: "bpmn:endEvent", flowNodeAction: "end", bidirectional: true },
+  { bpmnType: "bpmn:exclusiveGateway", flowNodeAction: "decision", bidirectional: true },
+  { bpmnType: "bpmn:parallelGateway", flowNodeAction: "parallel_gateway", bidirectional: true },
+  { bpmnType: "bpmn:serviceTask", flowNodeAction: "http_request", bidirectional: true, notes: "Maps HTTP/connector tasks" },
+  { bpmnType: "bpmn:scriptTask", flowNodeAction: "script", bidirectional: true },
+  { bpmnType: "bpmn:userTask", flowNodeAction: "screen", bidirectional: true },
+  { bpmnType: "bpmn:callActivity", flowNodeAction: "subflow", bidirectional: true },
+  { bpmnType: "bpmn:intermediateCatchEvent", flowNodeAction: "wait", bidirectional: true, notes: "Timer/signal/message catch events" },
+  { bpmnType: "bpmn:boundaryEvent", flowNodeAction: "boundary_event", bidirectional: true },
+  { bpmnType: "bpmn:task", flowNodeAction: "assignment", bidirectional: true, notes: "Generic BPMN task maps to assignment" }
+];
 
 exports.ActionRefSchema = ActionRefSchema;
 exports.ApprovalActionSchema = ApprovalActionSchema;
@@ -1531,6 +1912,16 @@ exports.ApproverType = ApproverType;
 exports.AuthFieldSchema = AuthFieldSchema;
 exports.AuthenticationSchema = AuthenticationSchema;
 exports.AuthenticationTypeSchema = AuthenticationTypeSchema;
+exports.BUILT_IN_BPMN_MAPPINGS = BUILT_IN_BPMN_MAPPINGS;
+exports.BpmnDiagnosticSchema = BpmnDiagnosticSchema;
+exports.BpmnElementMappingSchema = BpmnElementMappingSchema;
+exports.BpmnExportOptionsSchema = BpmnExportOptionsSchema;
+exports.BpmnImportOptionsSchema = BpmnImportOptionsSchema;
+exports.BpmnInteropResultSchema = BpmnInteropResultSchema;
+exports.BpmnUnmappedStrategySchema = BpmnUnmappedStrategySchema;
+exports.BpmnVersionSchema = BpmnVersionSchema;
+exports.CheckpointSchema = CheckpointSchema;
+exports.ConcurrencyPolicySchema = ConcurrencyPolicySchema;
 exports.ConflictResolutionSchema = ConflictResolutionSchema;
 exports.Connector = Connector;
 exports.ConnectorActionRefSchema = ConnectorActionRefSchema;
@@ -1555,18 +1946,26 @@ exports.ETLTransformationSchema = ETLTransformationSchema;
 exports.ETLTransformationTypeSchema = ETLTransformationTypeSchema;
 exports.EmailAlertActionSchema = EmailAlertActionSchema;
 exports.EventSchema = EventSchema;
+exports.ExecutionErrorSchema = ExecutionErrorSchema;
+exports.ExecutionErrorSeverity = ExecutionErrorSeverity;
+exports.ExecutionLogSchema = ExecutionLogSchema;
+exports.ExecutionStatus = ExecutionStatus;
+exports.ExecutionStepLogSchema = ExecutionStepLogSchema;
 exports.FieldUpdateActionSchema = FieldUpdateActionSchema;
 exports.FlowEdgeSchema = FlowEdgeSchema;
 exports.FlowNodeAction = FlowNodeAction;
 exports.FlowNodeSchema = FlowNodeSchema;
 exports.FlowSchema = FlowSchema;
 exports.FlowVariableSchema = FlowVariableSchema;
+exports.FlowVersionHistorySchema = FlowVersionHistorySchema;
 exports.GuardRefSchema = GuardRefSchema;
 exports.HttpCallActionSchema = HttpCallActionSchema;
+exports.NodeExecutorDescriptorSchema = NodeExecutorDescriptorSchema;
 exports.OAuth2ConfigSchema = OAuth2ConfigSchema;
 exports.OperationParameterSchema = OperationParameterSchema;
 exports.OperationTypeSchema = OperationTypeSchema;
 exports.PushNotificationActionSchema = PushNotificationActionSchema;
+exports.ScheduleStateSchema = ScheduleStateSchema;
 exports.StateMachineSchema = StateMachineSchema;
 exports.StateNodeSchema = StateNodeSchema;
 exports.Sync = Sync;
@@ -1577,6 +1976,11 @@ exports.SyncModeSchema = SyncModeSchema;
 exports.TaskCreationActionSchema = TaskCreationActionSchema;
 exports.TimeTriggerSchema = TimeTriggerSchema;
 exports.TransitionSchema = TransitionSchema;
+exports.WAIT_EXECUTOR_DESCRIPTOR = WAIT_EXECUTOR_DESCRIPTOR;
+exports.WaitEventTypeSchema = WaitEventTypeSchema;
+exports.WaitExecutorConfigSchema = WaitExecutorConfigSchema;
+exports.WaitResumePayloadSchema = WaitResumePayloadSchema;
+exports.WaitTimeoutBehaviorSchema = WaitTimeoutBehaviorSchema;
 exports.WebhookReceiverSchema = WebhookReceiverSchema;
 exports.WebhookSchema = WebhookSchema;
 exports.WebhookTriggerType = WebhookTriggerType;