@codemation/core 0.11.1 → 0.12.0

package/dist/{index-zWGtEhrf.d.ts → index-CSKKuK60.d.ts}

@@ -1,6 +1,6 @@
 import "reflect-metadata";
 import { DependencyContainer as Container, DependencyContainer as DependencyContainer$1, Disposable, InjectionToken as InjectionToken$1, InjectionToken as TypeToken, Lifecycle, RegistrationOptions, container as container$1, delay, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, predicateAwareClassFactory, registry, singleton } from "tsyringe";
-import { ZodType } from "zod";
+import { ZodType, z } from "zod";
 import { ReadableStream } from "node:stream/web";
 
 //#region src/contracts/baseTypes.d.ts
@@ -190,6 +190,19 @@ type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = Crede
   setupStatus: CredentialSetupStatus;
   createdAt: string;
   updatedAt: string;
+  /**
+   * Pointer to where the credential material bytes live. For OSS / standalone
+   * rows this is `{source: "local", ref: instanceId}` and the bytes co-locate
+   * with the row in the workspace DB. For managed-mode rows this is
+   * `{source: "control-plane", ref: <cp_id>}` and the bytes live at CP.
+   *
+   * The seam is read through `CredentialMaterialProvider`. See
+   * `docs/design/credentials-oauth-unification.md` ("Material provider seam").
+   */
+  material: Readonly<{
+    source: "local" | "control-plane";
+    ref: string;
+  }>;
 }>;
 /**
  * Arguments passed to `CredentialType.createSession` and `CredentialType.test`.
@@ -397,6 +410,16 @@ declare class CodemationTelemetryAttributeNames {
   static readonly mcpServerId = "mcp.server_id";
   /** MCP tool name on spans created for callTool invocations. */
   static readonly mcpToolName = "mcp.tool_name";
+  /** Terminal node-execution status (e.g. `"hitl-approved"`, `"hitl-rejected"`) on HITL outcome spans. */
+  static readonly nodeExecutionStatus = "codemation.node.execution_status";
+  /** Populated on run-halted spans; discriminates the halt reason (e.g. `"hitl-rejected"`). */
+  static readonly runHaltReason = "codemation.run.halt_reason";
+  /** Human task ID on `hitl.task.*` span events. */
+  static readonly hitlTaskId = "codemation.hitl.task_id";
+  /** HITL channel name (e.g. `"inbox"`, `"control-plane-inbox"`) on `hitl.task.*` span events. */
+  static readonly hitlChannel = "codemation.hitl.channel";
+  /** Decision outcome (e.g. `"approved"`, `"rejected"`) on `hitl.task.decided` span events. */
+  static readonly hitlDecisionStatus = "codemation.hitl.decision_status";
 }
 //#endregion
 //#region src/contracts/GenAiTelemetryAttributeNames.d.ts
@@ -573,6 +596,100 @@ interface WebhookTriggerMatcher {
 }
 //#endregion
 //#region src/contracts/runtimeTypes.d.ts
+/** Opaque unique identifier for a single HumanTask instance. */
+type HumanTaskId = string;
+/**
+ * Duration string — ISO 8601 duration ("PT24H") or shorthand ("24h").
+ * Parsed by the timeout job; stored as-is in the suspension record.
+ */
+type Duration = string;
+/**
+ * Minimal handle handed to the `deliver` callback so it can route to the correct
+ * inbox channel.
+ */
+interface HumanTaskHandle {
+  readonly taskId: HumanTaskId;
+  readonly runId: string;
+  readonly nodeId: string;
+  readonly expiresAt: Date;
+  /** TODO: real signed URL; placeholder empty string for now. */
+  readonly resumeUrl: string;
+  /**
+   * Arbitrary JSON metadata copied from `SuspensionRequest.request.metadata` at suspension time.
+   * Used by the agent runtime to round-trip the `agentCheckpoint` back to the
+   * resumed node via `ctx.resumeContext.task.metadata`.
+   */
+  readonly metadata?: Readonly<Record<string, JsonValue>>;
+}
+/** Human-readable description surface shown to the reviewer. */
+interface HumanTaskSubject {
+  readonly title: string;
+  readonly summary: string;
+  readonly attributes?: JsonValue;
+}
+/** Identity of the person who made a decision on the task. */
+interface HumanTaskActor {
+  readonly actorId: string;
+  readonly displayName?: string;
+}
+/**
+ * Resume context injected into `NodeExecutionContext` when the engine re-activates
+ * a previously suspended node. `defineHumanApprovalNode` wraps this with parsed
+ * `TDecision`; at the engine layer `decision.value` is `unknown`.
+ */
+interface ResumeContext {
+  readonly decision: Readonly<{
+    kind: "decided";
+    value: unknown;
+    actor: HumanTaskActor;
+    decidedAt: Date;
+  }> | Readonly<{
+    kind: "timed_out";
+    at: Date;
+  }> | Readonly<{
+    kind: "auto_accepted";
+    at: Date;
+  }>;
+  readonly delivery: JsonValue;
+  readonly task: HumanTaskHandle;
+}
+/**
+ * Thrown by a node's `execute()` to request durable suspension of the current item.
+ * The engine catches this, persists the suspension entry, calls `deliver`, and
+ * continues to the next item (per-item semantics).
+ *
+ * @example
+ * ```ts
+ * throw new SuspensionRequest({
+ *   decisionSchema: z.object({ approved: z.boolean() }),
+ *   timeout: "PT24H",
+ *   onTimeout: "halt",
+ *   subject: { title: "Approve invoice", summary: "Invoice #1234 needs approval" },
+ *   deliver: async (handle) => {
+ *     await notifySlack(handle);
+ *     return { channel: "slack", ts: "..." };
+ *   },
+ * });
+ * ```
+ */
+declare class SuspensionRequest<TDecision = unknown, TDelivery extends JsonValue = JsonValue> extends Error {
+  readonly request: Readonly<{
+    decisionSchema: ZodType<TDecision>;
+    timeout: Duration;
+    onTimeout: "halt" | "auto-accept";
+    subject: HumanTaskSubject;
+    metadata?: Readonly<Record<string, JsonValue>>;
+    deliver: (handle: HumanTaskHandle) => Promise<TDelivery>;
+  }>;
+  constructor(request: Readonly<{
+    decisionSchema: ZodType<TDecision>;
+    timeout: Duration;
+    onTimeout: "halt" | "auto-accept";
+    subject: HumanTaskSubject;
+    metadata?: Readonly<Record<string, JsonValue>>;
+    deliver: (handle: HumanTaskHandle) => Promise<TDelivery>;
+  }>);
+}
 interface WorkflowRunnerService {
   runById(args: {
     workflowId: WorkflowId;
@@ -706,6 +823,14 @@ interface ExecutionContext {
    * Collections registered in the codemation config, keyed by collection name.
    */
   readonly collections?: CollectionsContext;
+  /**
+   * Resolve a DI token from the host container.
+   * Allows nodes to reach host-side services (e.g. `InboxChannelResolverToken`)
+   * without importing host code. Wired by `DefaultExecutionContextFactory`; throws
+   * a clear error when no resolver is configured (e.g. in unit tests that don't
+   * set up the full container).
+   */
+  resolve<T>(token: TypeToken<T>): T;
 }
 interface ExecutionContextFactory {
   create(args: {
@@ -729,6 +854,11 @@ interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase>
   config: TConfig;
   telemetry: NodeExecutionTelemetry;
   binary: NodeBinaryAttachmentService;
+  /**
+   * Present when this node activation is a HITL resume.
+   * The node checks `ctx.resumeContext !== undefined` and takes the resume branch.
+   */
+  resumeContext?: ResumeContext;
 }
 interface PollingTriggerHandle {
   /**
@@ -1635,7 +1765,7 @@ interface RunQueueEntry {
     received: Readonly<Record<InputPortKey, Items>>;
   }>;
 }
-type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped";
+type NodeExecutionStatus = "pending" | "queued" | "running" | "completed" | "failed" | "skipped" | "hitl-approved" | "hitl-rejected" | "hitl-timeout" | "hitl-auto-accepted" | "hitl-cancelled";
 interface NodeExecutionError {
   message: string;
   name?: string;
@@ -1743,7 +1873,9 @@ interface ExecutionFrontierPlan {
   clearedNodeIds: ReadonlyArray<NodeId>;
   preservedPinnedNodeIds: ReadonlyArray<NodeId>;
 }
-type RunStatus = "running" | "pending" | "completed" | "failed";
+type RunStatus = "running" | "pending" | "completed" | "failed" | "suspended" | "halted";
+/** Reason a run transitioned to {@link RunStatus} `"halted"`. */
+type RunHaltReason = "hitl-rejected" | "hitl-timeout" | "hitl-cancelled";
 interface RunSummary {
   runId: RunId;
   workflowId: WorkflowId;
@@ -1777,6 +1909,35 @@ interface PersistedRunSchedulingState {
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
 }
+/** One persisted suspension entry per suspended item. */
+interface PersistedSuspensionEntry {
+  /** Opaque task identifier (UUID v4). */
+  readonly taskId: string;
+  readonly nodeId: NodeId;
+  readonly activationId: NodeActivationId;
+  readonly itemIndex: number;
+  /** SHA-256 hex digest of the decision schema JSON (for schema-drift detection). */
+  readonly decisionSchemaHash: string;
+  /** Serialized return value from `SuspensionRequest.deliver` (stored on the HumanTask row). */
+  readonly deliveryRef: JsonValue;
+  /** ISO timestamp when the task expires. */
+  readonly timeoutAt: string;
+  readonly onTimeout: "halt" | "auto-accept";
+}
+/**
+ * When a node is re-activated after suspension, the engine writes the resume context here
+ * so `NodeExecutionRequestHandlerService` can splice `resumeContext` into ctx.
+ * Cleared once the re-activation is consumed.
+ */
+interface PendingResumeEntry {
+  readonly activationId: NodeActivationId;
+  readonly nodeId: NodeId;
+  /**
+   * Typed as `unknown` here to avoid a circular import between runTypes ↔ runtimeTypes.
+   * `NodeExecutionRequestHandlerService` casts this to `ResumeContext` from runtimeTypes.
+   */
+  readonly resumeContext: unknown;
+}
 interface PersistedRunState {
   runId: RunId;
   workflowId: WorkflowId;
@@ -1795,12 +1956,24 @@ interface PersistedRunState {
   /** Successful node completions so far (for activation budget). */
   engineCounters?: EngineRunCounters;
   status: RunStatus;
+  /** Populated when `status === "halted"` to discriminate why the run was halted. */
+  reason?: RunHaltReason;
   pending?: PendingNodeExecution;
   queue: RunQueueEntry[];
   outputsByNode: Record<NodeId, NodeOutputs>;
   nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
   /** Append-only history of connection invocations (LLM/tool) nested under owning nodes. */
   connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
+  /**
+   * One entry per outstanding HITL suspension (per-item).
+   * Present and non-empty iff `status === "suspended"`.
+   */
+  suspension?: ReadonlyArray<PersistedSuspensionEntry>;
+  /**
+   * Written by `resumeRun()` so `NodeExecutionRequestHandlerService` can splice `resumeContext`
+   * into the ctx when re-executing the suspended node. Cleared once consumed.
+   */
+  pendingResume?: PendingResumeEntry;
 }
 interface WorkflowExecutionRepository {
   createRun(args: {
@@ -1860,6 +2033,12 @@ type RunResult = {
   error: {
     message: string;
   };
+} | {
+  runId: RunId;
+  workflowId: WorkflowId;
+  startedAt: string;
+  status: "halted";
+  reason: RunHaltReason;
 };
 type WebhookRunResult = Readonly<{
   runId: RunId;
@@ -2367,6 +2546,244 @@ declare class RunFinishedAtFactory {
   static resolveIso(state: RunFinishedAtSource): string | undefined;
 }
 //#endregion
+//#region src/authoring/defineNode.types.d.ts
+type MaybePromise<TValue> = TValue | Promise<TValue>;
+type ResolvableCredentialType = AnyCredentialType | CredentialTypeId;
+type SessionForCredentialType<TCredential extends ResolvableCredentialType> = TCredential extends AnyCredentialType ? Awaited<ReturnType<TCredential["createSession"]>> : unknown;
+type DefinedNodeCredentialBinding = ResolvableCredentialType | Readonly<{
+  readonly type: ResolvableCredentialType | ReadonlyArray<ResolvableCredentialType>;
+  readonly label?: string;
+  readonly optional?: true;
+  readonly helpText?: string;
+  readonly helpUrl?: string;
+}>;
+type DefinedNodeCredentialBindings = Readonly<Record<string, DefinedNodeCredentialBinding>>;
+type SessionForBinding<TBinding extends DefinedNodeCredentialBinding> = TBinding extends Readonly<{
+  type: infer TType;
+}> ? TType extends ReadonlyArray<infer TEntry> ? SessionForCredentialType<TEntry & ResolvableCredentialType> : SessionForCredentialType<TType & ResolvableCredentialType> : SessionForCredentialType<TBinding & ResolvableCredentialType>;
+type DefinedNodeCredentialAccessors<TBindings extends DefinedNodeCredentialBindings | undefined> = TBindings extends DefinedNodeCredentialBindings ? Readonly<{ [TKey in keyof TBindings]: () => Promise<SessionForBinding<TBindings[TKey]>> }> : Readonly<Record<string, never>>;
+interface DefinedNodeRunContext<TConfig extends CredentialJsonRecord, TBindings extends DefinedNodeCredentialBindings | undefined> {
+  readonly config: TConfig;
+  readonly credentials: DefinedNodeCredentialAccessors<TBindings>;
+  readonly execution: NodeExecutionContext<RunnableNodeConfig<TConfig, unknown>>;
+}
+/**
+ * Arguments for {@link defineNode} `execute` (engine `ctx` matches {@link RunnableNode.execute};
+ * the second callback parameter adds {@link DefinedNodeRunContext} for credential accessors).
+ */
+type DefineNodeExecuteArgs<TConfig extends CredentialJsonRecord, TInputJson$1> = Readonly<{
+  input: TInputJson$1;
+  item: Item;
+  itemIndex: number;
+  items: Items;
+  ctx: NodeExecutionContext<RunnableNodeConfig<TInputJson$1, unknown> & Readonly<{
+    config: TConfig;
+  }>>;
+}>;
+type DefinedNodeConfigInput<TConfigResolved extends CredentialJsonRecord, TItemJson> = ParamDeep<TConfigResolved, TItemJson>;
+interface DefinedNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, _TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly kind: "defined-node";
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  create<TConfigItemJson = TInputJson$1>(config: DefinedNodeConfigInput<TConfig, TConfigItemJson>, name?: string, id?: string): RunnableNodeConfig<TInputJson$1, TOutputJson$1>;
+  register(context: {
+    registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
+  }): void;
+}
+/**
+ * Plugin / DSL-friendly node: per-item `execute` with optional {@link RunnableNodeConfig.inputSchema}.
+ */
+interface DefineNodeOptions<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  /**
+   * Canvas icon for this node (same contract as `NodeConfigBase.icon` on runnable configs).
+   * The Next host resolves Lucide (`lucide:…`), built-in SVGs (`builtin:…`), Simple Icons (`si:…`), and image URLs (`https:`, `data:`, `/…`).
+   */
+  readonly icon?: string;
+  /** Default values / form hints for **static** node configuration (credentials, retry, IDs), not per-item payload. */
+  readonly input?: Readonly<Record<keyof TConfig & string, unknown>>;
+  readonly configSchema?: z.ZodType<TConfig>;
+  readonly credentials?: TBindings;
+  /**
+   * Validates **`input`** (engine also accepts `inputSchema` on the node class).
+   */
+  readonly inputSchema?: ZodType<TInputJson$1>;
+  /** Preserve inbound `item.binary` when `execute` returns plain JSON or item-shaped results without `binary`. */
+  readonly keepBinaries?: boolean;
+  /**
+   * Static configuration summary surfaced in the workflow inspector — see
+   * {@link import("../contracts/workflowTypes").NodeConfigBase.inspectorSummary}.
+   *
+   * Receives the static config; returns 2–6 short label/value pairs (or `undefined` to skip).
+   */
+  readonly inspectorSummary?: (args: Readonly<{
+    config: TConfig;
+  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
+  execute(args: DefineNodeExecuteArgs<TConfig, TInputJson$1>, context: DefinedNodeRunContext<TConfig, TBindings>): MaybePromise<TOutputJson$1>;
+}
+/**
+ * Batch-oriented defined node: `run` receives all item JSON once (last item in activation); emits one output per input row.
+ */
+interface DefineBatchNodeOptions<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
+  readonly key: TKey$1;
+  readonly title: string;
+  readonly description?: string;
+  readonly icon?: string;
+  readonly input?: Readonly<Record<keyof TConfig & string, unknown>>;
+  readonly configSchema?: z.ZodType<TConfig>;
+  readonly credentials?: TBindings;
+  readonly inspectorSummary?: (args: Readonly<{
+    config: TConfig;
+  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
+  run(items: ReadonlyArray<TInputJson$1>, context: DefinedNodeRunContext<TConfig, TBindings>): MaybePromise<ReadonlyArray<TOutputJson$1>>;
+}
+declare function defineNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineNodeOptions<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>): DefinedNode<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>;
+declare function defineBatchNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1, TOutputJson$1, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineBatchNodeOptions<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>): DefinedNode<TKey$1, TConfig, TInputJson$1, TOutputJson$1, TBindings>;
+//#endregion
+//#region src/authoring/defineHumanApprovalNode.types.d.ts
+/**
+ * Decision shape merged into `item.json` after a HITL approval task resolves.
+ *
+ * - `"approved"` / `"rejected"` — from a human decision (uses `approvedPredicate`).
+ * - `"timed-out"` — timeout fired with `onTimeout: "halt"`.
+ * - `"auto-accepted"` — timeout fired with `onTimeout: "auto-accept"`.
+ */
+interface HumanApprovalDecisionResult {
+  readonly status: "approved" | "rejected" | "timed-out" | "auto-accepted";
+  /** Identity of the person who decided; absent for automated outcomes. */
+  readonly actor?: HumanTaskActor;
+  /** ISO 8601 timestamp of the decision. */
+  readonly decidedAt?: Date;
+  /** Optional free-text note from the reviewer. */
+  readonly note?: string;
+  /**
+   * Full raw decision payload (only present for `"approved"` / `"rejected"`).
+   * Shape is determined by the channel's `decisionSchema`.
+   */
+  readonly payload?: Record<string, unknown>;
+}
+/**
+ * Output item shape emitted by a `defineHumanApprovalNode`-based node.
+ * Original `item.json` fields are preserved and `decision` is merged in.
+ * If the input `item.json` already contained a `decision` key it is **overwritten**.
+ */
+type HumanApprovalOutputJson<TInputJson$1 extends Record<string, unknown>> = TInputJson$1 & {
+  readonly decision: HumanApprovalDecisionResult;
+};
+/**
+ * Extends {@link DefinedNode} with the `humanApprovalToolBehavior` metadata marker.
+ * Story 10 reads this field when attaching the node as an agent tool.
+ */
+interface DefinedHumanApprovalNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1 extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> extends DefinedNode<TKey$1, TConfig, TInputJson$1, HumanApprovalOutputJson<TInputJson$1>, TBindings> {
+  /**
+   * Behavior hint consumed by the agent runtime (story 10) when this node is attached as a tool.
+   * `"return"` (default) — return the rejection to the agent as a tool result.
+   * `"halt"` — halt the agent run on rejection.
+   *
+   * Standalone DSL usage ignores this field.
+   */
+  readonly humanApprovalToolBehavior: {
+    onRejected: "return" | "halt";
+  };
+}
+/**
+ * Returns `true` when `node` was created by {@link defineHumanApprovalNode}.
+ * Uses the `humanApprovalToolBehavior` typed field as the discriminant.
+ */
+declare function isHumanApprovalNode(node: unknown): node is DefinedHumanApprovalNode<string, Record<string, unknown>, Record<string, unknown>, undefined>;
+/**
+ * Authoring helper that compiles a HITL approval channel down to a regular
+ * {@link defineNode}-backed node with `SuspensionRequest` semantics.
+ *
+ * **Fast-forward decision semantics:**
+ * - On the first `execute` call (no `ctx.resumeContext`): throws a `SuspensionRequest`
+ *   that calls the author's `deliver`. The engine persists the suspension and continues.
+ * - On resume (`ctx.resumeContext` set): calls `onDecision`/`onTimeout` as appropriate,
+ *   merges a `decision` key into `item.json`, and returns an item with the original
+ *   `binary` map passed by reference (no copy).
+ *
+ * **Output shape per item:**
+ * ```ts
+ * // Input:  { json: { invoiceId: 42 }, binary?: {...} }
+ * // Output: { json: { invoiceId: 42, decision: { status: "approved", actor, decidedAt } }, binary: <unchanged> }
+ * ```
+ * If `item.json` already has a `decision` key it is **overwritten**. Namespace as
+ * needed if your schema reserves that key for another purpose.
+ *
+ * **Predicate persistence:**
+ * The `approvedPredicate` function is NOT serialized to the suspension record (except
+ * as an audit-only string via `toString()`). On resume, the workflow definition is
+ * reloaded from code at process start and the predicate closure is rebuilt naturally.
+ * If a deploy ships a changed predicate between suspend and resume, the *new* predicate
+ * runs — document this in your runbook when the predicate carries business logic that
+ * may change across deploys.
+ *
+ * @example
+ * ```ts
+ * export const slackApprovalNode = defineHumanApprovalNode({
+ *   key: "my-plugin.slackApproval",
+ *   title: "Slack Approval",
+ *   channel: "slack",
+ *   configSchema: z.object({ channel: z.string(), message: z.string() }),
+ *   decisionSchema: z.object({ approved: z.boolean(), note: z.string().optional() }),
+ *
+ *   async deliver({ task, config, item }, ctx) {
+ *     const ts = await postSlackMessage(config.channel, `Approve? <${task.resumeUrl}>`);
+ *     return { channel: config.channel, ts };
+ *   },
+ *
+ *   async onDecision({ decision, actor, delivery }, ctx) {
+ *     await updateSlackMessage(delivery.channel, delivery.ts, decision.approved ? "✅" : "❌");
+ *   },
+ * });
+ * ```
+ */
+declare function defineHumanApprovalNode<TKey$1 extends string, TConfig extends CredentialJsonRecord, TInputJson$1 extends Record<string, unknown>, TDecision extends Record<string, unknown>, TDelivery extends JsonValue, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(opts: {
+  key: TKey$1;
+  title: string;
+  description?: string;
+  icon?: string;
+  channel: string;
+  configSchema: ZodType<TConfig>;
+  inputSchema?: ZodType<TInputJson$1>;
+  decisionSchema: ZodType<TDecision>;
+  credentials?: TBindings;
+  /**
+   * Custom predicate that decides whether a decision counts as "approved".
+   * When omitted, the helper checks if `decisionSchema` is a Zod object with an
+   * `approved: boolean` field; if so it uses `decision.approved === true`.
+   * If neither holds, `defineHumanApprovalNode` throws at **definition time** (not runtime).
+   */
+  approvedPredicate?: (decision: TDecision) => boolean;
+  /** Default suspension timeout. Defaults to `"24h"`. */
+  defaultTimeout?: Duration;
+  /** What to do when the task times out. Defaults to `"halt"`. */
+  defaultOnTimeout?: "halt" | "auto-accept";
+  inspectorSummary?: (config: TConfig) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
+  deliver: (args: {
+    task: HumanTaskHandle;
+    config: TConfig;
+    input: TInputJson$1;
+    item: Item;
+  }, ctx: ExecutionContext) => Promise<TDelivery>;
+  onDecision?: (args: {
+    decision: TDecision;
+    actor: HumanTaskActor;
+    task: HumanTaskHandle;
+    delivery: TDelivery;
+    item: Item;
+  }, ctx: ExecutionContext) => Promise<void>;
+  onTimeout?: (args: {
+    task: HumanTaskHandle;
+    delivery: TDelivery;
+    item: Item;
+    policy: "halt" | "auto-accept";
+  }, ctx: ExecutionContext) => Promise<void>;
+}): DefinedHumanApprovalNode<TKey$1, TConfig, TInputJson$1, TBindings>;
+//#endregion
 //#region src/workflow/dsl/workflowBuilderTypes.d.ts
 type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
 type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
@@ -2412,6 +2829,25 @@ declare class ChainCursor<TCurrentJson> {
   thenIntoInputHints<TOutputJson$1, TConfig extends RunnableNodeConfig<any, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
   readonly when: ChainCursorWhenOverloads<TCurrentJson>;
   route<TNextJson$1>(branches: Readonly<Record<OutputPortKey, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TNextJson$1> | undefined>>): ChainCursor<TNextJson$1>;
+  /**
+   * Chainable shorthand for `.then(node.create(config, metadata?.name, metadata?.nodeId))`.
+   *
+   * Signals to readers that this step suspends the run and waits for a human decision.
+   * Throws at workflow-build time if `node` was not created via `defineHumanApprovalNode`.
+   *
+   * @example
+   * ```ts
+   * workflow
+   *   .trigger(...)
+   *   .humanApproval(inboxApproval, { title: "Approve?", body: "...", priority: "normal" })
+   *   .then(nextStep.create(...))
+   *   .build();
+   * ```
+   */
+  humanApproval<TKey$1 extends string, TConfig extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(node: DefinedHumanApprovalNode<TKey$1, TConfig, TCurrentJson & Record<string, unknown>, TBindings>, config: TConfig, metadata?: {
+    name?: string;
+    nodeId?: string;
+  }): ChainCursor<HumanApprovalOutputJson<TCurrentJson & Record<string, unknown>>>;
   build(): WorkflowDefinition;
   private resolveSharedInputPortHint;
 }
@@ -2554,5 +2990,5 @@ declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
   create(def: WorkflowDefinition): WorkflowGraph;
 }
 //#endregion
-export { CostCatalogEntry as $, NodeId as $a, TelemetryChildSpanStart as $i, NodeInspectorSummaryRow as $n, ExecutionBinaryService as $r, WebhookRunResult as $t, isUnbrandedPortsEmissionShape as A, CredentialHealthTester as Aa, TriggerTestItemsContext as Ai, TestTriggerNodeConfig as An, WorkflowStoragePolicyMode as Ar, NodeInputsByPort as At, PersistedExecutionInstanceRecord as B, CredentialSessionService as Ba, WebhookInvocationMatch as Bi, JsonArray as Bn, FixedRetryPolicySpec as Br, PinnedNodeOutputsByPort as Bt, ExpRetryPolicy as C, CredentialAdvancedSectionPresentation as Ca, TestableTriggerNode as Ci, EngineExecutionLimitsPolicyConfig as Cn, WorkflowErrorHandlerSpec as Cr, ConnectionInvocationRecord as Ct, PortsEmission as D, CredentialFieldSchema as Da, TriggerSetupContext as Di, TestCaseRunStatus as Dn, WorkflowPolicyRuntimeDefaults as Dr, NodeExecutionError as Dt, getOriginIndexFromItem as E, CredentialBindingKey as Ea, TriggerRuntimeDiagnostics as Ei, RunEventSubscription as En, WorkflowNodeConnection as Er, ExecutionFrontierPlan as Et, ExecutionInstanceDto as F, CredentialOAuth2AuthDefinition as Fa, WorkflowSnapshotFactory as Fi, Edge as Fn, runnableNodeInputType as Fr, PersistedRunSchedulingState as Ft, RunRevision as G, CredentialTypeRegistry as Ga, WorkflowActivationPolicy as Gi, MutableRunData as Gn, BinaryStorage as Gr, RunPruneCandidate as Gt, PersistedRunWorkItemKind as H, CredentialType as Ha, WebhookTriggerResolution as Hi, JsonObject as Hn, RetryPolicySpec as Hr, RunCurrentState as Ht, ExecutionInstanceId as I, CredentialOAuth2ScopesFromPublicConfig as Ia, WorkflowSnapshotResolver as Ii, ExecutionMode as In, runnableNodeOutputType as Ir, PersistedRunState as It, WorkItemId as J, NoOpPollingTriggerLogger as Ja, NodeExecutionTelemetry as Ji, NodeDefinition as Jn, BinaryStorageWriteRequest as Jr, RunStateResetRequest as Jt, RunSlotProjectionState as K, CredentialUnboundError as Ka, ExecutionTelemetry as Ki, NodeActivationId as Kn, BinaryStorageReadResult as Kr, RunQueueEntry as Kt, ExecutionPayloadPolicyFields as L, CredentialRequirement as La, HttpMethod as Li, Item as Ln, triggerNodeOutputType as Lr, PersistedWorkflowSnapshot as Lt, McpServerTransport as M, CredentialInstanceRecord as Ma, WorkflowRepository as Mi, ActivationIdFactory as Mn, WorkflowStoragePolicySpec as Mr, PersistedMutableNodeState as Mt, BatchId as N, CredentialJsonRecord as Na, WorkflowRunnerResolver as Ni, BinaryAttachment as Nn, branchRef as Nr, PersistedMutableRunState as Nt, emitPorts as O, CredentialHealth as Oa, TriggerSetupStateFor as Oi, TestSuiteRunStatus as On, WorkflowPrunePolicySpec as Or, NodeExecutionSnapshot as Ot, ConnectionInvocationKind as P, CredentialMaterialSourceKind as Pa, WorkflowRunnerService as Pi, BinaryPreviewKind as Pn, nodeRef as Pr, PersistedRunControlState as Pt, CostCatalog as Q, NodeConnectionName as Qa, TelemetryAttributes as Qi, NodeIdRef as Qn, ExecutableTriggerNode as Qr, RunTestContext as Qt, PayloadStorageKind as R, CredentialSessionFactory as Ra, TriggerInstanceId as Ri, ItemBinary as Rn, triggerNodeSetupStateType as Rr, PersistedWorkflowSnapshotNode as Rt, NoOpCostTrackingTelemetry as S, AnyCredentialType as Sa, RunnableNodeExecuteArgs as Si, EngineExecutionLimitsPolicy as Sn, WorkflowErrorHandler as Sr, ConnectionInvocationId as St, NoRetryPolicy as T, CredentialBinding as Ta, TriggerNode as Ti, RunEventBus as Tn, WorkflowGraphFactory as Tr, EngineRunCounters as Tt, PersistedRunWorkItemRecord as U, CredentialTypeDefinition as Ua, WebhookTriggerRoutingDiagnostics as Ui, JsonPrimitive as Un, BinaryAttachmentCreateRequest as Ur, RunEventPublisherDeps as Ut, PersistedRunSlotProjectionRecord as V, CredentialSetupStatus as Va, WebhookTriggerMatcher as Vi, JsonNonArray as Vn, NoneRetryPolicySpec as Vr, RunCompletionNotifier as Vt, RunIterationDto as W, CredentialTypeId as Wa, AllWorkflowsActiveWorkflowActivationPolicy as Wi, JsonValue as Wn, BinaryBody as Wr, RunExecutionOptions as Wt, WorkflowDetailSelectionState as X, PollingTriggerDedupWindow as Xa, TelemetryArtifactReference as Xi, NodeErrorHandlerArgs as Xn, EngineDeps as Xr, RunStopCondition as Xt, WorkItemStatus as Y, PollingTriggerLogger as Ya, TelemetryArtifactAttachment as Yi, NodeErrorHandler as Yn, BinaryStorageWriteResult as Yr, RunStatus as Yt, WorkflowRunDetailDto as Z, InputPortKey as Za, TelemetryAttributePrimitive as Zi, NodeErrorHandlerSpec as Zn, EngineHost as Zr, RunSummary as Zt, BranchStepsArg as _, CostTrackingTelemetryFactory as _a, NodeResolver as _i, predicateAwareClassFactory as _n, TriggerNodeOutputJson as _r, AgentBindError as _t, ConnectionNodeIdFactory as a, CodemationTelemetryMetricNames as aa, NodeActivationContinuation as ai, Disposable as an, NodeSchedulerDecision as ar, ItemExprCallback as at, RunFinishedAtFactory as b, CollectionStore as ba, PreparedNodeActivationDispatch as bi, CoreTokens as bn, WorkflowDefinition as br, NeedsReconsentEvent as bt, WorkflowDefinitionError as c, NoOpExecutionTelemetryFactory as ca, NodeActivationRequestBase as ci, RegistrationOptions as cn, PersistedRunPolicySnapshot as cr, isItemExpr as ct, WhenBuilder as d, NoOpTelemetrySpanScope as da, NodeExecutionContext as di, delay as dn, RunId as dr, resolveItemExprsInUnknown as dt, TelemetryMetricRecord as ea, ExecutionContext as ei, WorkflowExecutionListingRepository as en, OutputPortKey as eo, NodeIterationId as er, Expr as et, AnyRunnableNodeConfig as f, NoOpTelemetryArtifactReference as fa, NodeExecutionRequest as fi, inject as fn, RunIdFactory as fr, AssertionResult as ft, BranchOutputGuard as g, CostTrackingTelemetryAttributeNames as ga, NodeExecutor as gi, instancePerContainerCachingFactory as gn, TriggerNodeConfig as gr, NoOpAgentMcpIntegration as gt, BranchMoreArgs as h, CostTrackingTelemetry as ha, NodeExecutionStatePublisher as hi, instanceCachingFactory as hn, RunnableNodeOutputJson as hr, deriveAssertionPassed as ht, NodeIterationIdFactory as i, TelemetrySpanScope as ia, MultiInputNode as ii, DependencyContainer$1 as in, NodeRef as ir, ItemExprArgs as it, McpServerDeclaration as j, CredentialInstanceId as ja, WorkflowNodeInstanceFactory as ji, TestTriggerSetupContext as jn, WorkflowStoragePolicyResolver as jr, PendingNodeExecution as jt, isPortsEmission as k, CredentialHealthStatus as ka, TriggerSetupStateRepository as ki, TestSuiteRunId as kn, WorkflowStoragePolicyDecisionArgs as kr, NodeExecutionStatus as kt, WorkflowBuilder as l, NoOpExecutionTelemetry as la, NodeActivationScheduler as li, TypeToken as ln, RunDataFactory as lr, itemExpr as lt, BooleanWhenOverloads as m, CostTrackingPriceQuote as ma, NodeExecutionScheduler as mi, injectable as mn, RunnableNodeInputJson as mr, DEFAULT_ASSERTION_PASS_THRESHOLD as mt, WorkflowExecutableNodeClassifierFactory as n, TelemetrySpanEnd as na, ItemNode as ni, WorkflowExecutionRepository as nn, WorkflowId as no, NodeOffloadPolicy as nr, ParamDeep as nt, ConnectionInvocationIdFactory as o, GenAiTelemetryAttributeNames as oa, NodeActivationReceipt as oi, InjectionToken$1 as on, PairedItemRef as or, ItemExprContext as ot, AnyTriggerNodeConfig as p, CostTrackingComponent as pa, NodeExecutionRequestHandler as pi, injectAll as pn, RunnableNodeConfig as pr, AssertionResultProvenance as pt, SlotExecutionStateDto as q, OAuth2ProviderFromPublicConfig as qa, ExecutionTelemetryFactory as qi, NodeConfigBase as qn, BinaryStorageStatResult as qr, RunResult as qt, WorkflowExecutableNodeClassifier as r, TelemetrySpanEventRecord as ra, LiveWorkflowRepository as ri, Container as rn, NodeOutputs as rr, ItemExpr as rt, NodeIdSlugifier as s, CodemationTelemetryAttributeNames as sa, NodeActivationRequest as si, Lifecycle as sn, ParentExecutionRef as sr, ItemExprResolvedContext as st, DefaultWorkflowGraphFactory as t, TelemetryScope as ta, ExecutionContextFactory as ti, WorkflowExecutionPruneRepository as tn, PersistedTokenId as to, NodeKind as tr, Param as tt, ChainCursor as u, NoOpNodeExecutionTelemetry as ua, NodeBinaryAttachmentService as ui, container$1 as un, RunDataSnapshot as ur, resolveItemExprsForExecution as ut, StepSequenceOutput as v, CostTrackingTelemetryMetricNames as va, PersistedTriggerSetupState as vi, registry as vn, TriggerNodeSetupState as vr, AgentMcpIntegration as vt, RetryPolicy as w, CredentialAuthDefinition as wa, TriggerCleanupHandle as wi, RunEvent as wn, WorkflowGraph as wr, CurrentStateExecutionRequest as wt, NoOpCostTrackingTelemetryFactory as x, CollectionsContext as xa, RunnableNode as xi, ENGINE_EXECUTION_LIMITS_DEFAULTS as xn, WorkflowErrorContext as xr, ConnectionInvocationAppendArgs as xt, ValidStepSequence as y, CostTrackingUsageRecord as ya, PollingTriggerHandle as yi, singleton as yn, UpstreamRefPlaceholder as yr, AgentMcpToolMap as yt, PersistedExecutionInstanceKind as z, CredentialSessionFactoryArgs as za, WebhookControlSignal as zi, Items as zn, ExponentialRetryPolicySpec as zr, PersistedWorkflowTokenRegistryLike as zt };
-//# sourceMappingURL=index-zWGtEhrf.d.ts.map
+export { ExecutionPayloadPolicyFields as $, CredentialFieldSchema as $a, TriggerSetupContext as $i, BinaryPreviewKind as $n, nodeRef as $r, PersistedRunState as $t, DefinedNodeCredentialAccessors as A, TelemetrySpanScope as Aa, NodeActivationReceipt as Ai, delay as An, RunId as Ar, DEFAULT_ASSERTION_PASS_THRESHOLD as At, RetryPolicy as B, CostTrackingPriceQuote as Ba, NodeExecutor as Bi, ENGINE_EXECUTION_LIMITS_DEFAULTS as Bn, WorkflowErrorContext as Br, CurrentStateExecutionRequest as Bt, defineHumanApprovalNode as C, TelemetryAttributePrimitive as Ca, HumanTaskHandle as Ci, DependencyContainer$1 as Cn, InputPortKey as Co, NodeRef as Cr, ItemExprResolvedContext as Ct, DefineNodeOptions as D, TelemetryScope as Da, LiveWorkflowRepository as Di, RegistrationOptions as Dn, PersistedTokenId as Do, PersistedRunPolicySnapshot as Dr, resolveItemExprsInUnknown as Dt, DefineNodeExecuteArgs as E, TelemetryMetricRecord as Ea, ItemNode as Ei, Lifecycle as En, OutputPortKey as Eo, ParentExecutionRef as Er, resolveItemExprsForExecution as Et, defineNode as F, NoOpExecutionTelemetry as Fa, NodeExecutionContext as Fi, instancePerContainerCachingFactory as Fn, TriggerNodeConfig as Fr, AgentMcpToolMap as Ft, isPortsEmission as G, CostTrackingUsageRecord as Ga, ResumeContext as Gi, RunEventSubscription as Gn, WorkflowNodeConnection as Gr, NodeExecutionStatus as Gt, getOriginIndexFromItem as H, CostTrackingTelemetryAttributeNames as Ha, PersistedTriggerSetupState as Hi, EngineExecutionLimitsPolicyConfig as Hn, WorkflowErrorHandlerSpec as Hr, ExecutionFrontierPlan as Ht, RunFinishedAtFactory as I, NoOpNodeExecutionTelemetry as Ia, NodeExecutionRequest as Ii, predicateAwareClassFactory as In, TriggerNodeOutputJson as Ir, NeedsReconsentEvent as It, McpServerTransport as J, AnyCredentialType as Ja, SuspensionRequest as Ji, TestSuiteRunId as Jn, WorkflowStoragePolicyDecisionArgs as Jr, PendingResumeEntry as Jt, isUnbrandedPortsEmissionShape as K, CollectionStore as Ka, RunnableNode as Ki, TestCaseRunStatus as Kn, WorkflowPolicyRuntimeDefaults as Kr, NodeInputsByPort as Kt, NoOpCostTrackingTelemetryFactory as L, NoOpTelemetrySpanScope as La, NodeExecutionRequestHandler as Li, registry as Ln, TriggerNodeSetupState as Lr, ConnectionInvocationAppendArgs as Lt, DefinedNodeCredentialBindings as M, GenAiTelemetryAttributeNames as Ma, NodeActivationRequestBase as Mi, injectAll as Mn, RunnableNodeConfig as Mr, NoOpAgentMcpIntegration as Mt, DefinedNodeRunContext as N, CodemationTelemetryAttributeNames as Na, NodeActivationScheduler as Ni, injectable as Nn, RunnableNodeInputJson as Nr, AgentBindError as Nt, DefinedNode as O, TelemetrySpanEnd as Oa, MultiInputNode as Oi, TypeToken as On, WorkflowId as Oo, RunDataFactory as Or, AssertionResult as Ot, defineBatchNode as P, NoOpExecutionTelemetryFactory as Pa, NodeBinaryAttachmentService as Pi, instanceCachingFactory as Pn, RunnableNodeOutputJson as Pr, AgentMcpIntegration as Pt, ExecutionInstanceId as Q, CredentialBindingKey as Qa, TriggerRuntimeDiagnostics as Qi, BinaryAttachment as Qn, branchRef as Qr, PersistedRunSchedulingState as Qt, NoOpCostTrackingTelemetry as R, NoOpTelemetryArtifactReference as Ra, NodeExecutionScheduler as Ri, singleton as Rn, UpstreamRefPlaceholder as Rr, ConnectionInvocationId as Rt, HumanApprovalOutputJson as S, TelemetryArtifactReference as Sa, HumanTaskActor as Si, Container as Sn, PollingTriggerDedupWindow as So, NodeOutputs as Sr, ItemExprContext as St, DefineBatchNodeOptions as T, TelemetryChildSpanStart as Ta, HumanTaskSubject as Ti, InjectionToken$1 as Tn, NodeId as To, PairedItemRef as Tr, itemExpr as Tt, PortsEmission as U, CostTrackingTelemetryFactory as Ua, PollingTriggerHandle as Ui, RunEvent as Un, WorkflowGraph as Ur, NodeExecutionError as Ut, NoRetryPolicy as V, CostTrackingTelemetry as Va, NodeResolver as Vi, EngineExecutionLimitsPolicy as Vn, WorkflowErrorHandler as Vr, EngineRunCounters as Vt, emitPorts as W, CostTrackingTelemetryMetricNames as Wa, PreparedNodeActivationDispatch as Wi, RunEventBus as Wn, WorkflowGraphFactory as Wr, NodeExecutionSnapshot as Wt, ConnectionInvocationKind as X, CredentialAuthDefinition as Xa, TriggerCleanupHandle as Xi, TestTriggerSetupContext as Xn, WorkflowStoragePolicyResolver as Xr, PersistedMutableRunState as Xt, BatchId as Y, CredentialAdvancedSectionPresentation as Ya, TestableTriggerNode as Yi, TestTriggerNodeConfig as Yn, WorkflowStoragePolicyMode as Yr, PersistedMutableNodeState as Yt, ExecutionInstanceDto as Z, CredentialBinding as Za, TriggerNode as Zi, ActivationIdFactory as Zn, WorkflowStoragePolicySpec as Zr, PersistedRunControlState as Zt, BranchStepsArg as _, WorkflowActivationPolicy as _a, EngineHost as _i, RunTestContext as _n, CredentialTypeRegistry as _o, NodeIdRef as _r, Param as _t, ConnectionNodeIdFactory as a, WorkflowRunnerResolver as aa, FixedRetryPolicySpec as ai, RunCompletionNotifier as an, CredentialJsonRecord as ao, JsonArray as ar, PersistedRunWorkItemRecord as at, DefinedHumanApprovalNode as b, NodeExecutionTelemetry as ba, ExecutionContext as bi, WorkflowExecutionPruneRepository as bn, NoOpPollingTriggerLogger as bo, NodeKind as br, ItemExprArgs as bt, WorkflowDefinitionError as c, WorkflowSnapshotResolver as ca, BinaryAttachmentCreateRequest as ci, RunExecutionOptions as cn, CredentialOAuth2ScopesFromPublicConfig as co, JsonPrimitive as cr, RunSlotProjectionState as ct, WhenBuilder as d, WebhookControlSignal as da, BinaryStorageReadResult as di, RunQueueEntry as dn, CredentialSessionFactoryArgs as do, NodeActivationId as dr, WorkItemStatus as dt, TriggerSetupStateFor as ea, runnableNodeInputType as ei, PersistedSuspensionEntry as en, CredentialHealth as eo, Edge as er, PayloadStorageKind as et, AnyRunnableNodeConfig as f, WebhookInvocationMatch as fa, BinaryStorageStatResult as fi, RunResult as fn, CredentialSessionService as fo, NodeConfigBase as fr, WorkflowDetailSelectionState as ft, BranchOutputGuard as g, AllWorkflowsActiveWorkflowActivationPolicy as ga, EngineDeps as gi, RunSummary as gn, CredentialTypeId as go, NodeErrorHandlerSpec as gr, Expr as gt, BranchMoreArgs as h, WebhookTriggerRoutingDiagnostics as ha, Duration as hi, RunStopCondition as hn, CredentialTypeDefinition as ho, NodeErrorHandlerArgs as hr, CostCatalogEntry as ht, NodeIterationIdFactory as i, WorkflowRepository as ia, ExponentialRetryPolicySpec as ii, PinnedNodeOutputsByPort as in, CredentialInstanceRecord as io, Items as ir, PersistedRunWorkItemKind as it, DefinedNodeCredentialBinding as j, CodemationTelemetryMetricNames as ja, NodeActivationRequest as ji, inject as jn, RunIdFactory as jr, deriveAssertionPassed as jt, DefinedNodeConfigInput as k, TelemetrySpanEventRecord as ka, NodeActivationContinuation as ki, container$1 as kn, RunDataSnapshot as kr, AssertionResultProvenance as kt, WorkflowBuilder as l, HttpMethod as la, BinaryBody as li, RunHaltReason as ln, CredentialRequirement as lo, JsonValue as lr, SlotExecutionStateDto as lt, BooleanWhenOverloads as m, WebhookTriggerResolution as ma, BinaryStorageWriteResult as mi, RunStatus as mn, CredentialType as mo, NodeErrorHandler as mr, CostCatalog as mt, WorkflowExecutableNodeClassifierFactory as n, TriggerTestItemsContext as na, triggerNodeOutputType as ni, PersistedWorkflowSnapshotNode as nn, CredentialHealthTester as no, Item as nr, PersistedExecutionInstanceRecord as nt, ConnectionInvocationIdFactory as o, WorkflowRunnerService as oa, NoneRetryPolicySpec as oi, RunCurrentState as on, CredentialMaterialSourceKind as oo, JsonNonArray as or, RunIterationDto as ot, AnyTriggerNodeConfig as p, WebhookTriggerMatcher as pa, BinaryStorageWriteRequest as pi, RunStateResetRequest as pn, CredentialSetupStatus as po, NodeDefinition as pr, WorkflowRunDetailDto as pt, McpServerDeclaration as q, CollectionsContext as qa, RunnableNodeExecuteArgs as qi, TestSuiteRunStatus as qn, WorkflowPrunePolicySpec as qr, PendingNodeExecution as qt, WorkflowExecutableNodeClassifier as r, WorkflowNodeInstanceFactory as ra, triggerNodeSetupStateType as ri, PersistedWorkflowTokenRegistryLike as rn, CredentialInstanceId as ro, ItemBinary as rr, PersistedRunSlotProjectionRecord as rt, NodeIdSlugifier as s, WorkflowSnapshotFactory as sa, RetryPolicySpec as si, RunEventPublisherDeps as sn, CredentialOAuth2AuthDefinition as so, JsonObject as sr, RunRevision as st, DefaultWorkflowGraphFactory as t, TriggerSetupStateRepository as ta, runnableNodeOutputType as ti, PersistedWorkflowSnapshot as tn, CredentialHealthStatus as to, ExecutionMode as tr, PersistedExecutionInstanceKind as tt, ChainCursor as u, TriggerInstanceId as ua, BinaryStorage as ui, RunPruneCandidate as un, CredentialSessionFactory as uo, MutableRunData as ur, WorkItemId as ut, StepSequenceOutput as v, ExecutionTelemetry as va, ExecutableTriggerNode as vi, WebhookRunResult as vn, CredentialUnboundError as vo, NodeInspectorSummaryRow as vr, ParamDeep as vt, isHumanApprovalNode as w, TelemetryAttributes as wa, HumanTaskId as wi, Disposable as wn, NodeConnectionName as wo, NodeSchedulerDecision as wr, isItemExpr as wt, HumanApprovalDecisionResult as x, TelemetryArtifactAttachment as xa, ExecutionContextFactory as xi, WorkflowExecutionRepository as xn, PollingTriggerLogger as xo, NodeOffloadPolicy as xr, ItemExprCallback as xt, ValidStepSequence as y, ExecutionTelemetryFactory as ya, ExecutionBinaryService as yi, WorkflowExecutionListingRepository as yn, OAuth2ProviderFromPublicConfig as yo, NodeIterationId as yr, ItemExpr as yt, ExpRetryPolicy as z, CostTrackingComponent as za, NodeExecutionStatePublisher as zi, CoreTokens as zn, WorkflowDefinition as zr, ConnectionInvocationRecord as zt };
+//# sourceMappingURL=index-CSKKuK60.d.ts.map