import { $ as injectAll, $i as OutputPortKey, $n as NodeActivationContinuation, $r as TelemetrySpanEnd, $t as RunId, A as RunHaltReason, Ai as CredentialInstanceId, An as RetryPolicySpec, Ar as WorkflowRunnerResolver, At as JsonPrimitive, B as WorkflowExecutionListingRepository, Bi as CredentialSetupStatus, Bn as EngineDeps, Br as WebhookTriggerRoutingDiagnostics, Bt as NodeInspectorSummaryRow, C as PersistedWorkflowSnapshotNode, Ci as CredentialAuthDefinition, Cn as runnableNodeInputType, Cr as TriggerRuntimeDiagnostics, Ct as ExecutionMode, D as RunCurrentState, Di as CredentialHealth, Dn as ExponentialRetryPolicySpec, Dr as TriggerTestItemsContext, Dt as JsonArray, E as RunCompletionNotifier, Ei as CredentialFieldSchema, En as triggerNodeSetupStateType, Er as TriggerSetupStateRepository, Et as Items, F as RunStatus, Fi as CredentialOAuth2ScopesFromPublicConfig, Fn as BinaryStorageReadResult, Fr as TriggerInstanceId, Ft as NodeDefinition, G as Disposable, Gi as CredentialUnboundError, Gn as ExecutionContextFactory, Gr as NodeExecutionTelemetry, Gt as NodeRef, H as WorkflowExecutionRepository, Hi as CredentialTypeDefinition, Hn as ExecutableTriggerNode, Hr as WorkflowActivationPolicy, Ht as NodeKind, I as RunStopCondition, Ii as CredentialRequirement, In as BinaryStorageStatResult, Ir as WebhookControlSignal, It as NodeErrorHandler, J as RegistrationOptions, Ji as PollingTriggerLogger, Jn as HumanTaskId, Jr as TelemetryAttributePrimitive, Jt as ParentExecutionRef, K as InjectionToken, Ki as OAuth2ProviderFromPublicConfig, Kn as HumanTaskActor, Kr as TelemetryArtifactAttachment, Kt as NodeSchedulerDecision, L as RunSummary, Li as CredentialSessionFactory, Ln as BinaryStorageWriteRequest, Lr as WebhookInvocationMatch, Lt as NodeErrorHandlerArgs, M as RunQueueEntry, Mi as CredentialJsonRecord, Mn as BinaryAttachmentCreateRequest, Mr as WorkflowSnapshotFactory, Mt as MutableRunData, N as RunResult, Ni as CredentialMaterialSourceKind, Nn as BinaryBody, Nr as WorkflowSnapshotResolver, Nt as NodeActivationId, O as RunEventPublisherDeps, Oi as CredentialHealthStatus, On as FixedRetryPolicySpec, Or as WorkflowNodeInstanceFactory, Ot as JsonNonArray, P as RunStateResetRequest, Pi as CredentialOAuth2AuthDefinition, Pn as BinaryStorage, Pr as HttpMethod, Pt as NodeConfigBase, Q as inject, Qi as NodeId, Qn as MultiInputNode, Qr as TelemetryScope, Qt as RunDataSnapshot, R as RunTestContext, Ri as CredentialSessionFactoryArgs, Rn as BinaryStorageWriteResult, Rr as WebhookTriggerMatcher, Rt as NodeErrorHandlerSpec, S as PersistedWorkflowSnapshot, Si as CredentialAdvancedSectionPresentation, Sn as nodeRef, Sr as TriggerPollingPort, St as Edge, T as PinnedNodeOutputsByPort, Ti as CredentialBindingKey, Tn as triggerNodeOutputType, Tr as TriggerSetupStateFor, Tt as ItemBinary, U as Container, Ui as CredentialTypeId, Un as ExecutionBinaryService, Ur as ExecutionTelemetry, Ut as NodeOffloadPolicy, V as WorkflowExecutionPruneRepository, Vi as CredentialType, Vn as EngineHost, Vr as AllWorkflowsActiveWorkflowActivationPolicy, Vt as NodeIterationId, W as DependencyContainer, Wi as CredentialTypeRegistry, Wn as ExecutionContext, Wr as ExecutionTelemetryFactory, Wt as NodeOutputs, X as container, Xi as InputPortKey, Xn as ItemNode, Xr as TelemetryChildSpanStart, Xt as PollingTriggerConfig, Y as TypeToken, Yi as PollingTriggerDedupWindow, Yn as HumanTaskSubject, Yr as TelemetryAttributes, Yt as PersistedRunPolicySnapshot, Z as delay, Zi as NodeConnectionName, Zn as LiveWorkflowRepository, Zr as TelemetryMetricRecord, Zt as RunDataFactory, _ as PersistedMutableRunState, _i as CollectionStore, _n as WorkflowStoragePolicyDecisionArgs, _r as RunnableNodeExecuteArgs, _t as TestTriggerNodeConfig, a as ConnectionInvocationId, ai as NoOpExecutionTelemetryFactory, an as TriggerNodeOutputJson, ar as NodeExecutionContext, at as singleton, b as PersistedRunState, bi as CredentialAccessTokenSessionArgs, bn as WorkflowStoragePolicySpec, br as TriggerCleanupHandle, bt as BinaryAttachment, c as EngineRunCounters, ci as NoOpTelemetrySpanScope, cn as WorkflowDefinition, cr as NodeExecutionScheduler, d as NodeExecutionSnapshot, di as CostTrackingPriceQuote, dn as WorkflowErrorHandlerSpec, dr as NodeResolver, dt as RunEvent, ea as PersistedTokenId, ei as TelemetrySpanEventRecord, en as RunIdFactory, er as NodeActivationReceipt, et as injectable, f as NodeExecutionStatus, fi as CostTrackingTelemetry, fn as WorkflowGraph, fr as PersistedTriggerSetupState, ft as RunEventBus, g as PersistedMutableNodeState, gi as CostTrackingUsageRecord, gn as WorkflowPrunePolicySpec, gr as RunnableNode, gt as TestSuiteRunId, h as PendingResumeEntry, hi as CostTrackingTelemetryMetricNames, hn as WorkflowPolicyRuntimeDefaults, hr as ResumeContext, ht as TestSuiteRunStatus, i as ConnectionInvocationAppendArgs, ii as CodemationTelemetryAttributeNames, in as TriggerNodeConfig, ir as NodeBinaryAttachmentService, it as registry, j as RunPruneCandidate, ji as CredentialInstanceRecord, jn as BINARY_DEFAULT_MAX_BYTES, jr as WorkflowRunnerService, jt as JsonValue, k as RunExecutionOptions, ki as CredentialHealthTester, kn as NoneRetryPolicySpec, kr as WorkflowRepository, kt as JsonObject, l as ExecutionFrontierPlan, li as NoOpTelemetryArtifactReference, ln as WorkflowErrorContext, lr as NodeExecutionStatePublisher, lt as EngineExecutionLimitsPolicy, m as PendingNodeExecution, mi as CostTrackingTelemetryFactory, mn as WorkflowNodeConnection, mr as PreparedNodeActivationDispatch, mt as TestCaseRunStatus, n as AgentMcpToolMap, ni as CodemationTelemetryMetricNames, nn as RunnableNodeInputJson, nr as NodeActivationRequestBase, nt as instancePerContainerCachingFactory, o as ConnectionInvocationRecord, oi as NoOpExecutionTelemetry, on as TriggerNodeSetupState, or as NodeExecutionRequest, ot as CoreTokens, p as NodeInputsByPort, pi as CostTrackingTelemetryAttributeNames, pn as WorkflowGraphFactory, pr as PollingTriggerHandle, pt as RunEventSubscription, q as Lifecycle, qi as NoOpPollingTriggerLogger, qn as HumanTaskHandle, qr as TelemetryArtifactReference, qt as PairedItemRef, r as NeedsReconsentEvent, ri as GenAiTelemetryAttributeNames, rn as RunnableNodeOutputJson, rr as NodeActivationScheduler, rt as predicateAwareClassFactory, s as CurrentStateExecutionRequest, si as NoOpNodeExecutionTelemetry, sn as UpstreamRefPlaceholder, sr as NodeExecutionRequestHandler, st as TriggerInvoker, t as AgentMcpIntegration, ta as WorkflowId, ti as TelemetrySpanScope, tn as RunnableNodeConfig, tr as NodeActivationRequest, tt as instanceCachingFactory, u as NodeExecutionError, ui as CostTrackingComponent, un as WorkflowErrorHandler, ur as NodeExecutor, ut as EngineExecutionLimitsPolicyConfig, v as PersistedRunControlState, vi as CollectionsContext, vn as WorkflowStoragePolicyMode, vr as SuspensionRequest, vt as TestTriggerSetupContext, w as PersistedWorkflowTokenRegistryLike, wi as CredentialBinding, wn as runnableNodeOutputType, wr as TriggerSetupContext, wt as Item, x as PersistedSuspensionEntry, xi as CredentialAccessTokenSessionFactory, xn as branchRef, xr as TriggerNode, xt as BinaryPreviewKind, y as PersistedRunSchedulingState, yi as AnyCredentialType, yn as WorkflowStoragePolicyResolver, yr as TestableTriggerNode, yt as ActivationIdFactory, z as WebhookRunResult, zi as CredentialSessionService, zn as Duration, zr as WebhookTriggerResolution, zt as NodeIdRef } from "./agentMcpTypes-BHX4RQCC.cjs";
import { A as DEFAULT_ASSERTION_PASS_THRESHOLD, C as SlotExecutionStateDto, D as WorkflowRunDetailDto, E as WorkflowDetailSelectionState, F as WorkflowDispatch, I as WorkspaceId, L as deserializeDispatch, M as NoOpAgentMcpIntegration, N as AgentBindError, O as AssertionResult, P as DispatchItemMeta, R as serializeDispatch, S as RunSlotProjectionState, T as WorkItemStatus, _ as PersistedRunSlotProjectionRecord, a as WorkflowDeploymentManifest, b as RunIterationDto, c as serializeManifest, d as ExecutionInstanceDto, f as ExecutionInstanceId, g as PersistedExecutionInstanceRecord, h as PersistedExecutionInstanceKind, i as ManifestTriggerConfig, j as deriveAssertionPassed, k as AssertionResultProvenance, l as BatchId, m as PayloadStorageKind, n as DeploymentManifestSchemaVersion, o as deserializeManifest, p as ExecutionPayloadPolicyFields, r as ManifestNodeCredentialShape, s as emitWorkflowManifest, t as DEPLOYMENT_MANIFEST_SCHEMA_VERSION, u as ConnectionInvocationKind, v as PersistedRunWorkItemKind, w as WorkItemId, x as RunRevision, y as PersistedRunWorkItemRecord } from "./deploymentManifestTypes-B8CDmZZK.cjs";
import { a as ItemExprArgs, c as ItemExprResolvedContext, d as resolveItemExprsForExecution, f as resolveItemExprsInUnknown, i as ItemExpr, l as isItemExpr, n as Param, o as ItemExprCallback, r as ParamDeep, s as ItemExprContext, t as Expr, u as itemExpr } from "./params-CrK4iuG1.cjs";
import { n as CostCatalogEntry, t as CostCatalog } from "./CostCatalogContract-Dwo-ZamG.cjs";
import { $ as McpServerDeclaration, A as ChatModelFactory, B as ZodSchemaAny, C as AgentToolDefinition, D as ChatLanguageModel, E as AgentTurnLimitBehavior, F as NodeBackedToolOutputMapperArgs, G as CallableToolFactory, H as AgentMessageConfigNormalizer, I as StructuredOutputOptions, J as CallableToolExecuteHandler, K as CallableToolConfig, L as Tool, M as NodeBackedToolInputMapper, N as NodeBackedToolInputMapperArgs, O as ChatLanguageModelCallOptions, P as NodeBackedToolOutputMapper, Q as RunFinishedAtFactory, R as ToolConfig, S as AgentToolCallPlanner, T as AgentToolToken, U as AgentToolFactory, V as AgentConfigInspector, W as CallableToolKindToken, X as NodeIterationIdFactory, Y as NodeBackedToolConfig, Z as ConnectionNodeIdFactory, _ as AgentMessageTemplateContent, a as AgentConnectionNodeRole, b as AgentTool, c as AgentCanvasPresentation, d as AgentMessageBuildArgs, et as McpServerTransport, f as AgentMessageConfig, g as AgentMessageTemplate, h as AgentMessageRole, i as AgentConnectionNodeDescriptor, j as NodeBackedToolConfigOptions, k as ChatModelConfig, l as AgentGuardrailConfig, m as AgentMessageLine, n as AgentConnectionCredentialSource, o as McpServerResolver, p as AgentMessageDto, q as CallableToolConfigOptions, r as AgentConnectionNodeCollector, s as AgentAttachmentRole, t as ItemsInputNormalizer, u as AgentGuardrailDefaults, v as AgentModelInvocationOptions, w as AgentToolExecuteArgs, x as AgentToolCall, y as AgentNodeConfig, z as ToolExecuteArgs } from "./ItemsInputNormalizer-A5txcOWX.cjs";
import { n as InMemoryLiveWorkflowRepository, t as RunIntentService } from "./RunIntentService-DKxuHTUz.cjs";
import { _ as HumanTaskRecord, a as ItemExprResolver, b as HumanTaskStoreToken, c as DefaultAsyncSleeper, d as UnavailableBinaryStorage, f as HitlResumeTokenSignerSeam, g as HitlWorkspaceIdToken, h as HitlTimeoutJobSchedulerToken, i as RunnableOutputBehaviorResolver, m as HitlTimeoutJobSchedulerSeam, n as InMemoryBinaryStorage, o as InProcessRetryRunner, p as HitlResumeTokenSignerToken, r as RunnableOutputBehavior, s as DefaultExecutionContextFactory, t as InMemoryRunDataFactory, u as DefaultExecutionBinaryService, v as HumanTaskStatus, x as CredentialResolverFactory, y as HumanTaskStore } from "./InMemoryRunDataFactory-D2U9azmZ.cjs";
import { ZodType, z } from "zod";

//#region src/contracts/emitPorts.d.ts
declare const EMIT_PORTS_BRAND: unique symbol;
type PortsEmission = Readonly<{
  readonly [EMIT_PORTS_BRAND]: true;
  readonly ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>;
}>;
declare function emitPorts(ports: Readonly<Partial<Record<OutputPortKey, Items | ReadonlyArray<JsonNonArray>>>>): PortsEmission;
declare function isPortsEmission(value: unknown): value is PortsEmission;
declare function isUnbrandedPortsEmissionShape(value: unknown): value is Readonly<{
  ports: unknown;
}>;
//#endregion
//#region src/contracts/itemMeta.d.ts
declare function getOriginIndexFromItem(item: Item): number | undefined;
//#endregion
//#region src/contracts/NoRetryPolicy.d.ts
declare class NoRetryPolicy implements NoneRetryPolicySpec {
  readonly kind: "none";
}
//#endregion
//#region src/contracts/RetryPolicy.d.ts
declare class RetryPolicy implements FixedRetryPolicySpec {
  readonly maxAttempts: number;
  readonly delayMs: number;
  readonly kind: "fixed";
  constructor(maxAttempts: number, delayMs: number);
  static readonly defaultForHttp: FixedRetryPolicySpec;
  static readonly defaultForAiAgent: FixedRetryPolicySpec;
}
//#endregion
//#region src/contracts/ExpRetryPolicy.d.ts
declare class ExpRetryPolicy implements ExponentialRetryPolicySpec {
  readonly maxAttempts: number;
  readonly initialDelayMs: number;
  readonly multiplier: number;
  readonly maxDelayMs?: number | undefined;
  readonly jitter?: boolean | undefined;
  readonly kind: "exponential";
  constructor(maxAttempts: number, initialDelayMs: number, multiplier: number, maxDelayMs?: number | undefined, jitter?: boolean | undefined);
}
//#endregion
//#region src/contracts/NoOpCostTrackingTelemetry.d.ts
declare class NoOpCostTrackingTelemetry implements CostTrackingTelemetry {
  captureUsage(_: CostTrackingUsageRecord): Promise<CostTrackingPriceQuote | undefined>;
  forScope(_: TelemetryScope): CostTrackingTelemetry;
}
//#endregion
//#region src/contracts/NoOpCostTrackingTelemetryFactory.d.ts
declare class NoOpCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
  create(_: Readonly<{
    telemetry: ExecutionTelemetry;
  }>): CostTrackingTelemetry;
}
//#endregion
//#region src/authoring/nodeBaseOptions.types.d.ts
interface NodeBaseOptions {
  readonly id?: string;
  readonly description?: string;
}
//#endregion
//#region src/authoring/defineNode.types.d.ts
type MaybePromise$2<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$1 extends CredentialJsonRecord, TBindings extends DefinedNodeCredentialBindings | undefined> {
  readonly config: TConfig$1;
  readonly credentials: DefinedNodeCredentialAccessors<TBindings>;
  readonly execution: NodeExecutionContext<RunnableNodeConfig<TConfig$1, unknown>>;
}
type DefineNodeExecuteArgs<TConfig$1 extends CredentialJsonRecord, TInputJson> = Readonly<{
  input: TInputJson;
  item: Item;
  itemIndex: number;
  items: Items;
  ctx: NodeExecutionContext<RunnableNodeConfig<TInputJson, unknown> & Readonly<{
    config: TConfig$1;
  }>>;
}>;
type DefinedNodeConfigInput<TConfigResolved extends CredentialJsonRecord, TItemJson> = ParamDeep<TConfigResolved, TItemJson>;
interface DefinedNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, _TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly kind: "defined-node";
  readonly key: TKey$1;
  readonly title: string;
  readonly description?: string;
  create<TConfigItemJson = TInputJson>(config: DefinedNodeConfigInput<TConfig$1, TConfigItemJson>, name?: string, idOrOptions?: string | NodeBaseOptions): RunnableNodeConfig<TInputJson, TOutputJson>;
  register(context: {
    registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
  }): void;
}
interface DefineNodeOptions<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly key: TKey$1;
  readonly title: string;
  readonly description?: string;
  readonly icon?: string;
  readonly input?: Readonly<Record<keyof TConfig$1 & string, unknown>>;
  readonly configSchema?: z.ZodType<TConfig$1>;
  readonly credentials?: TBindings;
  readonly inputSchema?: ZodType<TInputJson>;
  readonly keepBinaries?: boolean;
  readonly inspectorSummary?: (args: Readonly<{
    config: TConfig$1;
  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
  execute(args: DefineNodeExecuteArgs<TConfig$1, TInputJson>, context: DefinedNodeRunContext<TConfig$1, TBindings>): MaybePromise$2<TOutputJson>;
}
interface DefineBatchNodeOptions<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly key: TKey$1;
  readonly title: string;
  readonly description?: string;
  readonly icon?: string;
  readonly input?: Readonly<Record<keyof TConfig$1 & string, unknown>>;
  readonly configSchema?: z.ZodType<TConfig$1>;
  readonly credentials?: TBindings;
  readonly inspectorSummary?: (args: Readonly<{
    config: TConfig$1;
  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
  run(items: ReadonlyArray<TInputJson>, context: DefinedNodeRunContext<TConfig$1, TBindings>): MaybePromise$2<ReadonlyArray<TOutputJson>>;
}
declare function defineNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineNodeOptions<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>): DefinedNode<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>;
declare function defineBatchNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson, TOutputJson, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefineBatchNodeOptions<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>): DefinedNode<TKey$1, TConfig$1, TInputJson, TOutputJson, TBindings>;
//#endregion
//#region src/authoring/defineHumanApprovalNode.types.d.ts
interface HumanApprovalDecisionResult {
  readonly status: "approved" | "rejected" | "timed-out" | "auto-accepted";
  readonly actor?: HumanTaskActor;
  readonly decidedAt?: Date;
  readonly note?: string;
  readonly payload?: Record<string, unknown>;
}
type HumanApprovalOutputJson<TInputJson extends Record<string, unknown>> = TInputJson & {
  readonly decision: HumanApprovalDecisionResult;
};
interface DefinedHumanApprovalNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> extends DefinedNode<TKey$1, TConfig$1, TInputJson, HumanApprovalOutputJson<TInputJson>, TBindings> {
  readonly humanApprovalToolBehavior: {
    onRejected: "return" | "halt";
  };
}
declare function isHumanApprovalNode(node: unknown): node is DefinedHumanApprovalNode<string, Record<string, unknown>, Record<string, unknown>, undefined>;
declare function defineHumanApprovalNode<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TInputJson 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$1>;
  inputSchema?: ZodType<TInputJson>;
  decisionSchema: ZodType<TDecision>;
  credentials?: TBindings;
  approvedPredicate?: (decision: TDecision) => boolean;
  defaultTimeout?: Duration;
  defaultOnTimeout?: "halt" | "auto-accept";
  inspectorSummary?: (config: TConfig$1) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
  deliver: (args: {
    task: HumanTaskHandle;
    config: TConfig$1;
    input: TInputJson;
    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$1, TInputJson, TBindings>;
//#endregion
//#region src/workflow/dsl/workflowBuilderTypes.d.ts
declare function mergeForward<TIn, TOut>(config: RunnableNodeConfig<TIn, TOut>): RunnableNodeConfig<TIn, TIn & TOut>;
type AnyRunnableNodeConfig = RunnableNodeConfig<any, any>;
type AnyTriggerNodeConfig = TriggerNodeConfig<any>;
type ValidStepSequence<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps extends readonly [] ? readonly [] : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? readonly [TFirst, ...ValidStepSequence<TNextJson, TRest>] : never : never : TSteps;
type StepSequenceOutput<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? TSteps extends readonly [] ? TCurrentJson : TSteps extends readonly [infer TFirst, ...infer TRest] ? TFirst extends RunnableNodeConfig<TCurrentJson, infer TNextJson> ? TRest extends ReadonlyArray<AnyRunnableNodeConfig> ? StepSequenceOutput<TNextJson, TRest> : never : never : TCurrentJson : TCurrentJson;
type TypesMatch<TLeft, TRight> = [TLeft] extends [TRight] ? ([TRight] extends [TLeft] ? true : false) : false;
type BranchOutputGuard<TCurrentJson, TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined> = TypesMatch<StepSequenceOutput<TCurrentJson, TTrueSteps>, StepSequenceOutput<TCurrentJson, TFalseSteps>> extends true ? unknown : never;
type BranchStepsArg<TCurrentJson, TSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TSteps & ValidStepSequence<TCurrentJson, TSteps>;
type BranchMoreArgs<TCurrentJson, TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>> = TRestSteps & ValidStepSequence<RunnableNodeOutputJson<TFirstStep>, TRestSteps>;
type BooleanWhenOverloads<TCurrentJson, TReturn> = {
  <TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, steps: BranchStepsArg<TCurrentJson, TSteps>): TReturn;
  <TFirstStep extends RunnableNodeConfig<TCurrentJson, any>, TRestSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(branch: boolean, step: TFirstStep, ...more: BranchMoreArgs<TCurrentJson, TFirstStep, TRestSteps>): TReturn;
};
//#endregion
//#region src/workflow/dsl/WhenBuilder.d.ts
type WhenEndpoint = Readonly<{
  node: NodeRef;
  output: OutputPortKey;
  inputPortHint?: InputPortKey;
}>;
declare class WhenBuilder<TCurrentJson> {
  private readonly wf;
  private readonly from;
  private readonly branchPort;
  private readonly priorEndpoints;
  private armEndpoint;
  constructor(wf: WorkflowBuilder, from: NodeRef, branchPort: OutputPortKey, priorEndpoints?: ReadonlyArray<WhenEndpoint>);
  addBranch<TSteps extends ReadonlyArray<AnyRunnableNodeConfig>>(steps: TSteps & ValidStepSequence<TCurrentJson, TSteps>): this;
  readonly when: BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>>;
  then<TOutputJson, TConfig$1 extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(config: TConfig$1): ChainCursor<RunnableNodeOutputJson<TConfig$1>>;
  humanApproval<TKey$1 extends string, TConfig$1 extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(node: DefinedHumanApprovalNode<TKey$1, TConfig$1, TCurrentJson & Record<string, unknown>, TBindings>, config: TConfig$1, metadata?: {
    name?: string;
    nodeId?: string;
  }): ChainCursor<HumanApprovalOutputJson<TCurrentJson & Record<string, unknown>>>;
  build(): WorkflowDefinition;
  private get accumulatedEndpoints();
  private toCursor;
}
//#endregion
//#region src/workflow/dsl/ChainCursorResolver.d.ts
type ChainCursorEndpoint = Readonly<{
  node: NodeRef;
  output: OutputPortKey;
  inputPortHint?: InputPortKey;
}>;
type ChainCursorWhenOverloads<TCurrentJson> = BooleanWhenOverloads<TCurrentJson, WhenBuilder<TCurrentJson>> & {
  <TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined, TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> | undefined>(branches: Readonly<{
    true?: TTrueSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? BranchStepsArg<TCurrentJson, TTrueSteps> : never;
    false?: TFalseSteps extends ReadonlyArray<AnyRunnableNodeConfig> ? BranchStepsArg<TCurrentJson, TFalseSteps> : never;
  }> & BranchOutputGuard<TCurrentJson, TTrueSteps, TFalseSteps>): ChainCursor<StepSequenceOutput<TCurrentJson, TTrueSteps>>;
};
declare class ChainCursor<TCurrentJson> {
  private readonly wf;
  private readonly endpoints;
  constructor(wf: WorkflowBuilder, endpoints: ReadonlyArray<ChainCursorEndpoint>);
  then<TOutputJson, TConfig$1 extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(config: TConfig$1): ChainCursor<RunnableNodeOutputJson<TConfig$1>>;
  thenMerge<TOutputJson, TConfig$1 extends RunnableNodeConfig<TCurrentJson, TOutputJson>>(config: TConfig$1): ChainCursor<TCurrentJson & RunnableNodeOutputJson<TConfig$1>>;
  thenIntoInputHints<TOutputJson, TConfig$1 extends RunnableNodeConfig<any, TOutputJson>>(config: TConfig$1): ChainCursor<RunnableNodeOutputJson<TConfig$1>>;
  readonly when: ChainCursorWhenOverloads<TCurrentJson>;
  route<TNextJson$1>(branches: Readonly<Record<OutputPortKey, (branch: ChainCursor<TCurrentJson>) => ChainCursor<TNextJson$1> | undefined>>): ChainCursor<TNextJson$1>;
  humanApproval<TKey$1 extends string, TConfig$1 extends Record<string, unknown>, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(node: DefinedHumanApprovalNode<TKey$1, TConfig$1, TCurrentJson & Record<string, unknown>, TBindings>, config: TConfig$1, metadata?: {
    name?: string;
    nodeId?: string;
  }): ChainCursor<HumanApprovalOutputJson<TCurrentJson & Record<string, unknown>>>;
  build(): WorkflowDefinition;
  private resolveSharedInputPortHint;
}
//#endregion
//#region src/workflow/dsl/WorkflowBuilder.d.ts
declare class WorkflowBuilder {
  private readonly meta;
  private readonly options?;
  private readonly nodes;
  private readonly edges;
  constructor(meta: {
    id: WorkflowId;
    name: string;
  }, options?: Readonly<Record<string, never>> | undefined);
  private add;
  private connect;
  trigger<TConfig$1 extends AnyTriggerNodeConfig>(config: TConfig$1): ChainCursor<TriggerNodeOutputJson<TConfig$1>>;
  start<TConfig$1 extends AnyRunnableNodeConfig>(config: TConfig$1): ChainCursor<RunnableNodeOutputJson<TConfig$1>>;
  build(): WorkflowDefinition;
  private validateNodeIds;
}
//#endregion
//#region src/workflow/dsl/WorkflowDefinitionError.d.ts
declare class WorkflowDefinitionError extends Error {
  constructor(message: string);
}
//#endregion
//#region src/workflow/dsl/NodeIdSlugifier.d.ts
declare const NodeIdSlugifier: {
  slugify(label: string): string;
};
//#endregion
//#region src/workflow/definition/ConnectionInvocationIdFactory.d.ts
declare class ConnectionInvocationIdFactory {
  static create(): string;
  static createForTest(runId: string, connectionNodeId: NodeId, sequence: number): string;
}
//#endregion
//#region src/workflow/definition/WorkflowExecutableNodeClassifier.d.ts
declare class WorkflowExecutableNodeClassifier {
  private readonly connectionOwnedIds;
  constructor(workflow: WorkflowDefinition);
  isConnectionOwnedNodeId(nodeId: NodeId): boolean;
  isExecutableNodeId(nodeId: NodeId): boolean;
  filterExecutableNodeDefinitions(nodes: ReadonlyArray<NodeDefinition>): ReadonlyArray<NodeDefinition>;
  private collectConnectionOwnedIds;
  findDefaultExecutableStartNodeId(workflow: WorkflowDefinition): NodeId;
  firstExecutableNodeIdInDefinitionOrder(workflow: WorkflowDefinition): NodeId | undefined;
  lastExecutableNodeIdInDefinitionOrder(workflow: WorkflowDefinition): NodeId;
}
//#endregion
//#region src/workflow/definition/WorkflowExecutableNodeClassifierFactory.d.ts
declare class WorkflowExecutableNodeClassifierFactory {
  static create(workflow: WorkflowDefinition): WorkflowExecutableNodeClassifier;
}
//#endregion
//#region src/workflow/graph/DefaultWorkflowGraphFactory.d.ts
declare class DefaultWorkflowGraphFactory implements WorkflowGraphFactory {
  create(def: WorkflowDefinition): WorkflowGraph;
}
//#endregion
//#region src/events/NodeEventPublisher.d.ts
declare class NodeEventPublisher {
  private readonly eventBus;
  constructor(eventBus: RunEventBus | undefined);
  publish(kind: "nodeQueued" | "nodeStarted" | "nodeCompleted" | "nodeFailed", snapshot: NodeExecutionSnapshot): Promise<void>;
}
//#endregion
//#region src/contracts/Clock.d.ts
interface Clock {
  now(): Date;
}
declare class SystemClock implements Clock {
  now(): Date;
}
//#endregion
//#region src/contracts/inboxChannelTypes.d.ts
interface InboxChannel {
  readonly kind: "local" | "control-plane-inbox";
  deliver(args: InboxDeliverArgs): Promise<InboxDelivery>;
  updateOnDecision?(args: InboxOnDecisionArgs): Promise<void>;
  updateOnTimeout?(args: InboxOnTimeoutArgs): Promise<void>;
}
type InboxDeliverArgs = Readonly<{
  task: HumanTaskHandle;
  subject: HumanTaskSubject;
  priority: "low" | "normal" | "high";
  item: Item;
  workspaceId?: string;
}>;
type InboxDelivery = {
  kind: "local";
  inboxItemId: string;
} | {
  kind: "cp";
  inboxItemId: string;
  workspaceId: string;
};
type InboxOnDecisionArgs = Readonly<{
  delivery: InboxDelivery;
  decision: {
    approved: boolean;
    note?: string;
  };
  actor: HumanTaskActor;
}>;
type InboxOnTimeoutArgs = Readonly<{
  delivery: InboxDelivery;
  policy: "halt" | "auto-accept";
}>;
interface InboxChannelResolverSeam {
  resolve(): {
    channel: InboxChannel;
    workspaceId?: string;
  };
}
declare const InboxChannelResolverToken: TypeToken<InboxChannelResolverSeam | undefined>;
declare const LocalInboxChannelToken: TypeToken<InboxChannel | undefined>;
declare const ControlPlaneInboxChannelToken: TypeToken<InboxChannel | undefined>;
//#endregion
//#region src/authoring/DefinedNodeRegistry.d.ts
declare class DefinedNodeRegistry {
  private static readonly definitions;
  static register(definition: DefinedNode<string, Record<string, unknown>, unknown, unknown>): void;
  static resolve(key: string): DefinedNode<string, Record<string, unknown>, unknown, unknown> | undefined;
}
//#endregion
//#region src/authoring/defineCredential.types.d.ts
type MaybePromise$1<TValue> = TValue | Promise<TValue>;
type CredentialFieldInput = CredentialFieldSchema["type"] | Readonly<Omit<CredentialFieldSchema, "key">>;
type CredentialFieldMap<TConfig$1 extends CredentialJsonRecord> = Readonly<Record<keyof TConfig$1 & string, CredentialFieldInput>>;
type ZodObjectSchema<TConfig$1 extends CredentialJsonRecord = CredentialJsonRecord> = z.ZodType<TConfig$1>;
type InferCredentialConfig<TSource> = TSource extends z.ZodType<infer TConfig, any, any> ? Readonly<TConfig> & CredentialJsonRecord : TSource extends CredentialFieldMap<infer TConfig> ? TConfig : CredentialJsonRecord;
interface DefineCredentialOptions<TPublicSource extends CredentialFieldMap<any> | ZodObjectSchema<any>, TSecretSource extends CredentialFieldMap<any> | ZodObjectSchema<any>, TSession> {
  readonly key: string;
  readonly label: string;
  readonly description?: string;
  readonly public: TPublicSource;
  readonly secret: TSecretSource;
  readonly supportedSourceKinds?: CredentialTypeDefinition["supportedSourceKinds"];
  readonly auth?: CredentialTypeDefinition["auth"];
  createSession(args: CredentialSessionFactoryArgs<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>>): MaybePromise$1<TSession>;
  test(args: CredentialSessionFactoryArgs<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>>): MaybePromise$1<CredentialHealth>;
}
declare function defineCredential<TPublicSource extends CredentialFieldMap<any> | ZodObjectSchema<any>, TSecretSource extends CredentialFieldMap<any> | ZodObjectSchema<any>, TSession>(options: DefineCredentialOptions<TPublicSource, TSecretSource, TSession>): CredentialType<InferCredentialConfig<TPublicSource>, InferCredentialConfig<TSecretSource>, TSession> & {
  readonly key: string;
};
//#endregion
//#region src/authoring/callableTool.types.d.ts
declare function callableTool<TInputSchema extends ZodSchemaAny, TOutputSchema extends ZodSchemaAny>(options: CallableToolConfigOptions<TInputSchema, TOutputSchema>): CallableToolConfig<TInputSchema, TOutputSchema>;
//#endregion
//#region src/authoring/defineCollection.types.d.ts
type CollectionFieldType = "text" | "int" | "bigint" | "double" | "bool" | "timestamptz" | "jsonb" | "uuid";
interface CollectionColumnBuilder {
  notNull(): CollectionColumnBuilder;
  default(value: unknown): CollectionColumnBuilder;
  readonly _type: CollectionFieldType;
  readonly _nullable: boolean;
  readonly _default?: unknown;
}
declare const c: {
  readonly text: () => CollectionColumnBuilder;
  readonly int: () => CollectionColumnBuilder;
  readonly bigint: () => CollectionColumnBuilder;
  readonly double: () => CollectionColumnBuilder;
  readonly bool: () => CollectionColumnBuilder;
  readonly timestamptz: () => CollectionColumnBuilder;
  readonly jsonb: () => CollectionColumnBuilder;
  readonly uuid: () => CollectionColumnBuilder;
};
interface CollectionFieldDefinition {
  readonly type: CollectionFieldType;
  readonly nullable: boolean;
  readonly default?: unknown;
}
interface CollectionIndexDefinition {
  readonly on: ReadonlyArray<string>;
  readonly unique?: boolean;
}
interface CollectionDefinition {
  readonly name: string;
  readonly fields: Readonly<Record<string, CollectionFieldDefinition>>;
  readonly indexes: ReadonlyArray<CollectionIndexDefinition>;
}
interface DefinedCollection<TDefinition extends CollectionDefinition = CollectionDefinition> {
  readonly kind: "defined-collection";
  readonly definition: TDefinition;
  register(context: {
    registerCollection(d: CollectionDefinition): void;
  }): void;
}
interface DefineCollectionOptions {
  readonly name: string;
  readonly fields: Record<string, CollectionColumnBuilder>;
  readonly indexes?: ReadonlyArray<CollectionIndexDefinition>;
}
declare function defineCollection<TName extends string>(options: DefineCollectionOptions & {
  name: TName;
}): DefinedCollection<CollectionDefinition & {
  name: TName;
}>;
//#endregion
//#region src/authoring/DefinedCollectionRegistry.d.ts
declare class DefinedCollectionRegistry {
  private static readonly definitions;
  static register(definition: CollectionDefinition): void;
  static resolve(name: string): CollectionDefinition | undefined;
  static list(): ReadonlyArray<CollectionDefinition>;
}
//#endregion
//#region src/authoring/definePollingTrigger.types.d.ts
type MaybePromise<TValue> = TValue | Promise<TValue>;
interface DefinePollingTriggerPollContext<TConfig$1 extends CredentialJsonRecord, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined> {
  readonly config: TConfig$1;
  readonly state: TState;
  readonly credentials: DefinedNodeCredentialAccessors<TBindings>;
}
interface DefinePollingTriggerPollResult<TItemJson, TState extends JsonValue | undefined> {
  readonly items: ReadonlyArray<{
    json: TItemJson;
    dedupKey?: string;
  }>;
  readonly nextState: TState;
}
type DefinePollingTriggerExecuteContext<TConfig$1 extends TriggerNodeConfig<any, any>> = NodeExecutionContext<TConfig$1>;
type DefinePollingTriggerTestItemsContext<TConfig$1 extends TriggerNodeConfig<any, any>> = TriggerTestItemsContext<TConfig$1>;
interface DefinePollingTriggerOptions<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly key: TKey$1;
  readonly packageName?: string;
  readonly title: string;
  readonly description?: string;
  readonly icon?: string;
  readonly configSchema?: ZodType<TConfig$1>;
  readonly credentials?: TBindings;
  readonly inspectorSummary?: (args: Readonly<{
    config: TConfig$1;
  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined;
  initialState?(): TState;
  readonly pollIntervalMs?: number;
  poll(pollCtx: DefinePollingTriggerPollContext<TConfig$1, TState, TBindings>): MaybePromise<DefinePollingTriggerPollResult<TItemJson, TState>>;
  execute?(items: Items<TItemJson>, ctx: NodeExecutionContext<DefinedPollingTriggerConfig<TConfig$1, TItemJson>>): MaybePromise<NodeOutputs>;
  testItems?(ctx: TriggerTestItemsContext<DefinedPollingTriggerConfig<TConfig$1, TItemJson>>): MaybePromise<Items<TItemJson>>;
}
interface DefinedPollingTrigger<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly kind: "defined-polling-trigger";
  readonly key: TKey$1;
  readonly title: string;
  readonly description?: string;
  create(cfg: TConfig$1, name?: string, idOrOptions?: string | NodeBaseOptions): DefinedPollingTriggerConfig<TConfig$1, TItemJson>;
  poll(pollCtx: Omit<DefinePollingTriggerPollContext<TConfig$1, TState, TBindings>, "credentials"> & {
    credentials?: DefinedNodeCredentialAccessors<TBindings>;
  }): MaybePromise<DefinePollingTriggerPollResult<TItemJson, TState>>;
  register(context: {
    registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
  }): void;
}
declare class DefinedPollingTriggerConfig<TConfig$1 extends CredentialJsonRecord, TItemJson> implements TriggerNodeConfig<TItemJson, JsonValue | undefined>, PollingTriggerConfig {
  readonly name: string;
  readonly cfg: TConfig$1;
  private readonly credentialRequirements;
  private readonly inspectorSummaryFn?;
  private readonly defaultPollIntervalMs?;
  readonly kind: "trigger";
  readonly type: TypeToken<unknown>;
  readonly icon: string | undefined;
  readonly id?: string;
  readonly description?: string;
  constructor(name: string, cfg: TConfig$1, typeToken: TypeToken<unknown>, icon: string | undefined, credentialRequirements: ReadonlyArray<CredentialRequirement>, idOrOptions?: string | NodeBaseOptions, inspectorSummaryFn?: ((args: Readonly<{
    config: TConfig$1;
  }>) => ReadonlyArray<NodeInspectorSummaryRow> | undefined) | undefined, defaultPollIntervalMs?: number | undefined);
  getCredentialRequirements(): ReadonlyArray<CredentialRequirement>;
  getTriggerPollConfig(): Readonly<{
    config: JsonObject;
    pollIntervalMs?: number;
  }>;
  inspectorSummary(): ReadonlyArray<NodeInspectorSummaryRow> | undefined;
}
declare function definePollingTrigger<TKey$1 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefinePollingTriggerOptions<TKey$1, TConfig$1, TItemJson, TState, TBindings>): DefinedPollingTrigger<TKey$1, TConfig$1, TItemJson, TState, TBindings>;
//#endregion
//#region src/events/ConnectionInvocationEventPublisher.d.ts
declare class ConnectionInvocationEventPublisher {
  private readonly eventBus;
  private readonly parent;
  constructor(eventBus: RunEventBus | undefined, parent: ParentExecutionRef | undefined);
  publish(record: ConnectionInvocationRecord): Promise<void>;
  private kindFor;
}
//#endregion
//#region src/events/InMemoryRunEventBusRegistry.d.ts
declare class InMemoryRunEventBus implements RunEventBus {
  private readonly globalListeners;
  private readonly listenersByWorkflowId;
  publish(event: RunEvent): Promise<void>;
  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
}
//#endregion
//#region src/events/EventPublishingWorkflowExecutionRepository.d.ts
declare class EventPublishingWorkflowExecutionRepository implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository {
  private readonly inner;
  private readonly eventBus;
  private readonly now;
  constructor(inner: WorkflowExecutionRepository, eventBus: RunEventBus, now?: () => Date);
  createRun(args: Parameters<WorkflowExecutionRepository["createRun"]>[0]): Promise<void>;
  load(runId: RunId): Promise<PersistedRunState | undefined>;
  loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined>;
  save(state: PersistedRunState): Promise<void>;
  deleteRun(runId: RunId): Promise<void>;
  listRuns(args?: Readonly<{
    workflowId?: WorkflowId;
    limit?: number;
  }>): Promise<ReadonlyArray<RunSummary>>;
  listRunsOlderThan(args: Readonly<{
    nowIso: string;
    defaultRetentionSeconds: number;
    limit?: number;
  }>): Promise<ReadonlyArray<RunPruneCandidate>>;
}
//#endregion
//#region src/runtime-types/persistedRuntimeTypeModelRegistry.d.ts
type DecoratedRuntimeType = Readonly<{
  name?: string;
}> & object;
type PersistedRuntimeTypeKind = "node" | "tool" | "chatModel";
interface PersistedRuntimeTypeDecoratorOptions {
  readonly name?: string;
  readonly packageName?: string;
  readonly moduleUrl?: string;
}
interface PersistedRuntimeTypeMetadata {
  readonly persistedName: string;
  readonly kind: PersistedRuntimeTypeKind;
  readonly packageName: string;
  readonly sourceHint?: string;
}
//#endregion
//#region src/runtime-types/InjectableRuntimeDecoratorComposerRegistry.d.ts
declare class InjectableRuntimeDecoratorComposer {
  static compose(kind: PersistedRuntimeTypeKind, options: PersistedRuntimeTypeDecoratorOptions, decoratorFileUrl: string): ClassDecorator;
}
//#endregion
//#region src/runtime-types/PersistedRuntimeTypeMetadataStoreRegistry.d.ts
declare class PersistedRuntimeTypeMetadataStore {
  static define(target: DecoratedRuntimeType, kind: PersistedRuntimeTypeKind, options: PersistedRuntimeTypeDecoratorOptions, decoratorFileUrl: string): void;
  static get(target: unknown): PersistedRuntimeTypeMetadata | undefined;
}
//#endregion
//#region src/runtime-types/PersistedRuntimeTypeNameResolver.d.ts
declare class PersistedRuntimeTypeNameResolver {
  static resolve(target: DecoratedRuntimeType, override: string | undefined): string;
}
//#endregion
//#region src/runtime-types/StackTraceCallSitePathResolver.d.ts
declare class StackTraceCallSitePathResolver {
  static resolve(decoratorFileUrl: string): string | undefined;
  private static extractPath;
}
//#endregion
//#region src/runtime-types/runtimeTypeDecorators.types.d.ts
declare function getPersistedRuntimeTypeMetadata(target: unknown): PersistedRuntimeTypeMetadata | undefined;
declare function node(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
declare function tool(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
declare function chatModel(options?: PersistedRuntimeTypeDecoratorOptions): ClassDecorator;
//#endregion
//#region src/execution/ChildExecutionScopeFactory.d.ts
declare class ChildExecutionScopeFactory {
  private readonly activationIdFactory;
  constructor(activationIdFactory: ActivationIdFactory);
  forSubAgent<TConfig$1 extends RunnableNodeConfig<any, any>>(args: Readonly<{
    parentCtx: NodeExecutionContext<TConfig$1>;
    childNodeId: NodeId;
    childConfig: TConfig$1;
    parentInvocationId: ConnectionInvocationId;
    parentSpan: TelemetrySpanScope;
  }>): NodeExecutionContext<TConfig$1>;
}
//#endregion
//#region src/execution/NodeOutputNormalizer.d.ts
declare class NodeOutputNormalizer {
  normalizeExecuteResult(args: Readonly<{
    baseItem: Item;
    raw: unknown;
    behavior: RunnableOutputBehavior;
  }>): NodeOutputs;
  private arrayFanOutToMain;
  private emitPortsToOutputs;
  private normalizePortPayload;
  private isItemLike;
  private isPlainJsonObject;
  private applyOutput;
}
//#endregion
//#region src/triggers/polling/PollingTriggerRuntime.d.ts
interface PollingRunCycleArgs<TState> {
  previousState: TState | undefined;
  signal: AbortSignal;
}
interface PollingRunCycleResult<TState, TItem> {
  items: Items<TItem>;
  nextState: TState;
}
interface PollingTriggerStartArgs<TState, TItem> {
  trigger: TriggerInstanceId;
  intervalMs: number;
  seedState?: TState;
  runCycle: (cycleCtx: PollingRunCycleArgs<TState>) => Promise<PollingRunCycleResult<TState, TItem>>;
  emit: (items: Items) => Promise<void>;
}
declare class PollingTriggerRuntime {
  private readonly triggerSetupStateRepository;
  private readonly logger;
  private readonly activeTriggers;
  private readonly intervalsByTrigger;
  private readonly busyTriggers;
  constructor(triggerSetupStateRepository: TriggerSetupStateRepository, logger: PollingTriggerLogger);
  start<TState, TItem>(args: PollingTriggerStartArgs<TState, TItem>): Promise<TState | undefined>;
  stop(trigger: TriggerInstanceId): Promise<void>;
  private ensureLoop;
  private runCycle;
  private toKey;
  private describe;
  private logError;
}
//#endregion
//#region src/validation/WorkflowEdgePortError.types.d.ts
interface WorkflowEdgePortError {
  readonly edge: Edge;
  readonly sourceNodeId: NodeId;
  readonly sourceNodeName: string | undefined;
  readonly sourceNodeKind: string | undefined;
  readonly badPort: OutputPortKey;
  readonly allowedPorts: ReadonlyArray<string>;
  readonly message: string;
}
interface WorkflowEdgePortValidationResult {
  readonly valid: boolean;
  readonly errors: ReadonlyArray<WorkflowEdgePortError>;
}
//#endregion
//#region src/validation/WorkflowEdgePortValidator.d.ts
declare class WorkflowEdgePortValidator {
  validate(workflow: {
    nodes: ReadonlyArray<NodeDefinition>;
    edges: ReadonlyArray<Edge>;
  }): WorkflowEdgePortValidationResult;
  private allowedOutputPorts;
}
//#endregion
//#region src/credentials/OAuthFlowExecutor.types.d.ts
interface OAuthFlowStartArgs {
  readonly typeId: string;
  readonly scopes: ReadonlyArray<string>;
  readonly redirectUri: string;
  readonly instanceId?: string;
}
interface OAuthFlowStartResult {
  readonly consentUrl: string;
  readonly stateToken: string;
}
interface OAuthFlowCallbackArgs {
  readonly stateToken: string;
  readonly code: string;
}
interface OAuthMaterial {
  readonly accessToken: string;
  readonly refreshToken?: string;
  readonly expiresAt?: string;
  readonly grantedScopes: ReadonlyArray<string>;
}
interface OAuthFlowExecutor {
  start(args: OAuthFlowStartArgs): Promise<OAuthFlowStartResult>;
  lookupInstanceId(stateToken: string): string | undefined;
  completeCallback(args: OAuthFlowCallbackArgs): Promise<OAuthMaterial>;
  refresh(args: {
    typeId: string;
    instanceId: string;
    material: OAuthMaterial;
  }): Promise<OAuthMaterial>;
}
//#endregion
//#region src/credentials/CredentialMaterialProvider.types.d.ts
type CredentialMaterialRef = Readonly<{
  source: "local" | "control-plane";
  id: string;
}>;
type MaterialBundle = OAuthMaterial;
type CallerContext = Readonly<{
  workspaceId: string;
  caller: Readonly<{
    kind: "workflow-node";
    workflowId: string;
    nodeId: string;
  }> | Readonly<{
    kind: "concierge";
    chatId: string;
  }> | Readonly<{
    kind: "research-agent";
    chatId: string;
  }> | Readonly<{
    kind: "manual";
    userId: string;
  }>;
  reason?: string;
}>;
interface CredentialMaterialProvider {
  getMaterial(ref: CredentialMaterialRef, context: CallerContext): Promise<MaterialBundle>;
  setMaterial(ref: CredentialMaterialRef, material: MaterialBundle): Promise<void>;
}
declare class IllegalMaterialSourceError extends Error {
  readonly source: CredentialMaterialRef["source"];
  readonly providerName: string;
  constructor(source: CredentialMaterialRef["source"], providerName: string);
}
//#endregion
//#region src/credentials/ManagedCredentialMaterialWriteError.d.ts
declare class ManagedCredentialMaterialWriteError extends Error {
  constructor(message?: string);
}
//#endregion
//#region src/credentials/ManagedMaterialFetchError.d.ts
declare class ManagedMaterialFetchError extends Error {
  readonly status: number;
  readonly providerErrorBody: string;
  constructor(status: number, providerErrorBody: string, message?: string);
}
//#endregion
//#region src/contracts/workspaceFileTypes.d.ts
interface WorkspaceFileMetadata {
  readonly key: string;
  readonly fileId: string;
  readonly filename: string;
  readonly contentType: string;
  readonly size: number;
  readonly lastModified: Date;
}
interface IWorkspaceFileStorage {
  listFiles(filenameFilter?: string): Promise<ReadonlyArray<WorkspaceFileMetadata>>;
  getFileByName(filename: string): Promise<WorkspaceFileMetadata>;
  getFileById(fileId: string): Promise<WorkspaceFileMetadata>;
  getStream(key: string): Promise<ReadableStream<Uint8Array>>;
  writeFile(filename: string, body: Uint8Array, contentType: string): Promise<WorkspaceFileMetadata>;
}
declare class WorkspaceFileNotFoundError extends Error {
  readonly key: string;
  constructor(key: string);
}
interface IWorkspaceFileRegistrar {
  register(meta: WorkspaceFileMetadata): Promise<void>;
}
declare const WorkspaceFileStorageToken: TypeToken<IWorkspaceFileStorage | undefined>;
declare const WorkspaceFileRegistrarToken: TypeToken<IWorkspaceFileRegistrar | undefined>;
//#endregion
export { ActivationIdFactory, AgentAttachmentRole, AgentBindError, AgentCanvasPresentation, AgentConfigInspector, type AgentConnectionCredentialSource, AgentConnectionNodeCollector, type AgentConnectionNodeDescriptor, type AgentConnectionNodeRole, AgentGuardrailConfig, AgentGuardrailDefaults, AgentMcpIntegration, AgentMcpToolMap, AgentMessageBuildArgs, AgentMessageConfig, AgentMessageConfigNormalizer, AgentMessageDto, AgentMessageLine, AgentMessageRole, AgentMessageTemplate, AgentMessageTemplateContent, AgentModelInvocationOptions, AgentNodeConfig, AgentTool, AgentToolCall, AgentToolCallPlanner, AgentToolDefinition, AgentToolExecuteArgs, AgentToolFactory, AgentToolToken, AgentTurnLimitBehavior, AllWorkflowsActiveWorkflowActivationPolicy, AnyCredentialType, AnyRunnableNodeConfig, AnyTriggerNodeConfig, AssertionResult, AssertionResultProvenance, BINARY_DEFAULT_MAX_BYTES, BatchId, BinaryAttachment, BinaryAttachmentCreateRequest, BinaryBody, BinaryPreviewKind, BinaryStorage, BinaryStorageReadResult, BinaryStorageStatResult, BinaryStorageWriteRequest, BinaryStorageWriteResult, BooleanWhenOverloads, BranchMoreArgs, BranchOutputGuard, BranchStepsArg, CallableToolConfig, CallableToolConfigOptions, CallableToolExecuteHandler, CallableToolFactory, CallableToolKindToken, type CallerContext, ChainCursor, ChatLanguageModel, ChatLanguageModelCallOptions, ChatModelConfig, ChatModelFactory, ChildExecutionScopeFactory, type Clock, CodemationTelemetryAttributeNames, CodemationTelemetryMetricNames, CollectionColumnBuilder, CollectionDefinition, CollectionFieldDefinition, CollectionIndexDefinition, CollectionStore, CollectionsContext, ConnectionInvocationAppendArgs, ConnectionInvocationEventPublisher, ConnectionInvocationId, ConnectionInvocationIdFactory, ConnectionInvocationKind, ConnectionInvocationRecord, ConnectionNodeIdFactory, Container, ControlPlaneInboxChannelToken, CoreTokens, CostCatalog, CostCatalogEntry, CostTrackingComponent, CostTrackingPriceQuote, CostTrackingTelemetry, CostTrackingTelemetryAttributeNames, CostTrackingTelemetryFactory, CostTrackingTelemetryMetricNames, CostTrackingUsageRecord, CredentialAccessTokenSessionArgs, CredentialAccessTokenSessionFactory, CredentialAdvancedSectionPresentation, CredentialAuthDefinition, CredentialBinding, CredentialBindingKey, CredentialFieldSchema, CredentialHealth, CredentialHealthStatus, CredentialHealthTester, CredentialInstanceId, CredentialInstanceRecord, CredentialJsonRecord, type CredentialMaterialProvider, type CredentialMaterialRef, CredentialMaterialSourceKind, CredentialOAuth2AuthDefinition, CredentialOAuth2ScopesFromPublicConfig, CredentialRequirement, CredentialResolverFactory, CredentialSessionFactory, CredentialSessionFactoryArgs, CredentialSessionService, CredentialSetupStatus, CredentialType, CredentialTypeDefinition, CredentialTypeId, CredentialTypeRegistry, CredentialUnboundError, CurrentStateExecutionRequest, DEFAULT_ASSERTION_PASS_THRESHOLD, DEPLOYMENT_MANIFEST_SCHEMA_VERSION, DefaultAsyncSleeper, DefaultExecutionBinaryService, DefaultExecutionContextFactory, DefaultWorkflowGraphFactory, DefineBatchNodeOptions, DefineCollectionOptions, DefineCredentialOptions, DefineNodeExecuteArgs, DefineNodeOptions, DefinePollingTriggerExecuteContext, DefinePollingTriggerOptions, DefinePollingTriggerPollContext, DefinePollingTriggerPollResult, DefinePollingTriggerTestItemsContext, DefinedCollection, DefinedCollectionRegistry, DefinedHumanApprovalNode, DefinedNode, DefinedNodeConfigInput, DefinedNodeCredentialAccessors, DefinedNodeCredentialBinding, DefinedNodeCredentialBindings, DefinedNodeRegistry, DefinedNodeRunContext, DefinedPollingTrigger, DefinedPollingTriggerConfig, DependencyContainer, DeploymentManifestSchemaVersion, DispatchItemMeta, Disposable, type Duration, Edge, EngineDeps, EngineExecutionLimitsPolicy, type EngineExecutionLimitsPolicyConfig, EngineHost, EngineRunCounters, EventPublishingWorkflowExecutionRepository, ExecutableTriggerNode, ExecutionBinaryService, ExecutionContext, ExecutionContextFactory, ExecutionFrontierPlan, ExecutionInstanceDto, ExecutionInstanceId, ExecutionMode, ExecutionPayloadPolicyFields, ExecutionTelemetry, ExecutionTelemetryFactory, ExpRetryPolicy, ExponentialRetryPolicySpec, Expr, FixedRetryPolicySpec, GenAiTelemetryAttributeNames, type HitlResumeTokenSignerSeam, HitlResumeTokenSignerToken, type HitlTimeoutJobSchedulerSeam, HitlTimeoutJobSchedulerToken, HitlWorkspaceIdToken, HttpMethod, HumanApprovalDecisionResult, HumanApprovalOutputJson, type HumanTaskActor, type HumanTaskHandle, type HumanTaskId, type HumanTaskRecord, type HumanTaskStatus, type HumanTaskStore, HumanTaskStoreToken, type HumanTaskSubject, type IWorkspaceFileRegistrar, type IWorkspaceFileStorage, IllegalMaterialSourceError, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryRunEventBus, InProcessRetryRunner, type InboxChannel, type InboxChannelResolverSeam, InboxChannelResolverToken, type InboxDeliverArgs, type InboxDelivery, type InboxOnDecisionArgs, type InboxOnTimeoutArgs, InjectableRuntimeDecoratorComposer, InjectionToken, InputPortKey, Item, ItemBinary, ItemExpr, ItemExprArgs, ItemExprCallback, ItemExprContext, ItemExprResolvedContext, ItemExprResolver, ItemNode, Items, ItemsInputNormalizer, JsonArray, JsonNonArray, JsonObject, JsonPrimitive, JsonValue, Lifecycle, LiveWorkflowRepository, LocalInboxChannelToken, ManagedCredentialMaterialWriteError, ManagedMaterialFetchError, ManifestNodeCredentialShape, ManifestTriggerConfig, type MaterialBundle, McpServerDeclaration, type McpServerResolver, McpServerTransport, MultiInputNode, MutableRunData, NeedsReconsentEvent, NoOpAgentMcpIntegration, NoOpCostTrackingTelemetry, NoOpCostTrackingTelemetryFactory, NoOpExecutionTelemetry, NoOpExecutionTelemetryFactory, NoOpNodeExecutionTelemetry, NoOpPollingTriggerLogger, NoOpTelemetryArtifactReference, NoOpTelemetrySpanScope, NoRetryPolicy, NodeActivationContinuation, NodeActivationId, NodeActivationReceipt, NodeActivationRequest, NodeActivationRequestBase, NodeActivationScheduler, NodeBackedToolConfig, NodeBackedToolConfigOptions, NodeBackedToolInputMapper, NodeBackedToolInputMapperArgs, NodeBackedToolOutputMapper, NodeBackedToolOutputMapperArgs, NodeBaseOptions, NodeBinaryAttachmentService, NodeConfigBase, NodeConnectionName, NodeDefinition, NodeErrorHandler, NodeErrorHandlerArgs, NodeErrorHandlerSpec, NodeEventPublisher, NodeExecutionContext, NodeExecutionError, NodeExecutionRequest, NodeExecutionRequestHandler, NodeExecutionScheduler, NodeExecutionSnapshot, NodeExecutionStatePublisher, NodeExecutionStatus, NodeExecutionTelemetry, NodeExecutor, NodeId, NodeIdRef, NodeIdSlugifier, NodeInputsByPort, NodeInspectorSummaryRow, NodeIterationId, NodeIterationIdFactory, NodeKind, NodeOffloadPolicy, NodeOutputNormalizer, NodeOutputs, NodeRef, NodeResolver, NodeSchedulerDecision, NoneRetryPolicySpec, OAuth2ProviderFromPublicConfig, type OAuthFlowCallbackArgs, type OAuthFlowExecutor, type OAuthFlowStartArgs, type OAuthFlowStartResult, type OAuthMaterial, OutputPortKey, PairedItemRef, Param, ParamDeep, ParentExecutionRef, PayloadStorageKind, PendingNodeExecution, type PendingResumeEntry, PersistedExecutionInstanceKind, PersistedExecutionInstanceRecord, PersistedMutableNodeState, PersistedMutableRunState, PersistedRunControlState, PersistedRunPolicySnapshot, PersistedRunSchedulingState, PersistedRunSlotProjectionRecord, PersistedRunState, PersistedRunWorkItemKind, PersistedRunWorkItemRecord, type PersistedRuntimeTypeDecoratorOptions, type PersistedRuntimeTypeKind, type PersistedRuntimeTypeMetadata, PersistedRuntimeTypeMetadataStore, PersistedRuntimeTypeNameResolver, type PersistedSuspensionEntry, PersistedTokenId, PersistedTriggerSetupState, PersistedWorkflowSnapshot, PersistedWorkflowSnapshotNode, PersistedWorkflowTokenRegistryLike, PinnedNodeOutputsByPort, type PollingRunCycleArgs, type PollingRunCycleResult, PollingTriggerConfig, PollingTriggerDedupWindow, PollingTriggerHandle, type PollingTriggerLogger, PollingTriggerRuntime, type PollingTriggerStartArgs, PortsEmission, PreparedNodeActivationDispatch, RegistrationOptions, type ResumeContext, RetryPolicy, RetryPolicySpec, RunCompletionNotifier, RunCurrentState, RunDataFactory, RunDataSnapshot, RunEvent, RunEventBus, RunEventPublisherDeps, RunEventSubscription, RunExecutionOptions, RunFinishedAtFactory, type RunHaltReason, RunId, RunIdFactory, RunIntentService, RunIterationDto, RunPruneCandidate, RunQueueEntry, RunResult, RunRevision, RunSlotProjectionState, RunStateResetRequest, RunStatus, RunStopCondition, RunSummary, RunTestContext, RunnableNode, RunnableNodeConfig, RunnableNodeExecuteArgs, RunnableNodeInputJson, RunnableNodeOutputJson, RunnableOutputBehaviorResolver, SlotExecutionStateDto, StackTraceCallSitePathResolver, StepSequenceOutput, StructuredOutputOptions, SuspensionRequest, SystemClock, TelemetryArtifactAttachment, TelemetryArtifactReference, TelemetryAttributePrimitive, TelemetryAttributes, TelemetryChildSpanStart, TelemetryMetricRecord, TelemetryScope, TelemetrySpanEnd, TelemetrySpanEventRecord, TelemetrySpanScope, TestCaseRunStatus, TestSuiteRunId, TestSuiteRunStatus, TestTriggerNodeConfig, TestTriggerSetupContext, TestableTriggerNode, Tool, ToolConfig, ToolExecuteArgs, TriggerCleanupHandle, TriggerInstanceId, TriggerInvoker, TriggerNode, TriggerNodeConfig, TriggerNodeOutputJson, TriggerNodeSetupState, TriggerPollingPort, TriggerRuntimeDiagnostics, TriggerSetupContext, TriggerSetupStateFor, TriggerSetupStateRepository, TriggerTestItemsContext, TypeToken, UnavailableBinaryStorage, UpstreamRefPlaceholder, ValidStepSequence, WebhookControlSignal, WebhookInvocationMatch, WebhookRunResult, WebhookTriggerMatcher, WebhookTriggerResolution, WebhookTriggerRoutingDiagnostics, WhenBuilder, WorkItemId, WorkItemStatus, WorkflowActivationPolicy, WorkflowBuilder, WorkflowDefinition, WorkflowDefinitionError, WorkflowDeploymentManifest, WorkflowDetailSelectionState, WorkflowDispatch, type WorkflowEdgePortError, type WorkflowEdgePortValidationResult, WorkflowEdgePortValidator, WorkflowErrorContext, WorkflowErrorHandler, WorkflowErrorHandlerSpec, WorkflowExecutableNodeClassifier, WorkflowExecutableNodeClassifierFactory, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository, WorkflowExecutionRepository, WorkflowGraph, WorkflowGraphFactory, WorkflowId, WorkflowNodeConnection, WorkflowNodeInstanceFactory, WorkflowPolicyRuntimeDefaults, WorkflowPrunePolicySpec, WorkflowRepository, WorkflowRunDetailDto, WorkflowRunnerResolver, WorkflowRunnerService, WorkflowSnapshotFactory, WorkflowSnapshotResolver, WorkflowStoragePolicyDecisionArgs, WorkflowStoragePolicyMode, WorkflowStoragePolicyResolver, WorkflowStoragePolicySpec, type WorkspaceFileMetadata, WorkspaceFileNotFoundError, WorkspaceFileRegistrarToken, WorkspaceFileStorageToken, WorkspaceId, ZodSchemaAny, branchRef, c, callableTool, chatModel, container, defineBatchNode, defineCollection, defineCredential, defineHumanApprovalNode, defineNode, definePollingTrigger, delay, deriveAssertionPassed, deserializeDispatch, deserializeManifest, emitPorts, emitWorkflowManifest, getOriginIndexFromItem, getPersistedRuntimeTypeMetadata, inject, injectAll, injectable, instanceCachingFactory, instancePerContainerCachingFactory, isHumanApprovalNode, isItemExpr, isPortsEmission, isUnbrandedPortsEmissionShape, itemExpr, mergeForward, node, nodeRef, predicateAwareClassFactory, registry, resolveItemExprsForExecution, resolveItemExprsInUnknown, runnableNodeInputType, runnableNodeOutputType, serializeDispatch, serializeManifest, singleton, tool, triggerNodeOutputType, triggerNodeSetupStateType };
//# sourceMappingURL=index.d.cts.map