import "reflect-metadata";
import { ReadableStream } from "node:stream/web";
import { ZodType, z } from "zod";
import { DependencyContainer, DependencyContainer as Container, InjectionToken as TypeToken } from "tsyringe";

//#region ../core/src/contracts/testTriggerTypes.d.ts
type TestSuiteRunId = string;
//#endregion
//#region ../core/src/contracts/baseTypes.d.ts
type WorkflowId = string;
type NodeId = string;
type OutputPortKey = string;
type InputPortKey = string;
type PersistedTokenId = string;
type NodeConnectionName = string;
//#endregion
//#region ../core/src/contracts/CostTrackingTelemetryContract.d.ts
type CostTrackingComponent = "chat" | "ocr" | "rag";
interface CostTrackingUsageRecord {
  readonly component: CostTrackingComponent;
  readonly provider: string;
  readonly operation: string;
  readonly pricingKey: string;
  readonly usageUnit: string;
  readonly quantity: number;
  readonly modelName?: string;
  readonly attributes?: TelemetryAttributes;
}
interface CostTrackingPriceQuote {
  readonly currency: string;
  readonly currencyScale: number;
  readonly estimatedAmountMinor: number;
  readonly estimateKind: "catalog";
}
interface CostTrackingTelemetry {
  captureUsage(args: CostTrackingUsageRecord): Promise<CostTrackingPriceQuote | undefined>;
  forScope(scope: TelemetryScope): CostTrackingTelemetry;
}
//#endregion
//#region ../core/src/contracts/telemetryTypes.d.ts
type TelemetryAttributePrimitive = string | number | boolean | null;
interface TelemetryAttributes {
  readonly [key: string]: TelemetryAttributePrimitive | undefined;
}
interface TelemetryMetricRecord {
  readonly name: string;
  readonly value: number;
  readonly unit?: string;
  readonly attributes?: TelemetryAttributes;
}
interface TelemetrySpanEventRecord {
  readonly name: string;
  readonly occurredAt?: Date;
  readonly attributes?: TelemetryAttributes;
}
interface TelemetryArtifactAttachment {
  readonly kind: string;
  readonly contentType: string;
  readonly previewText?: string;
  readonly previewJson?: JsonValue;
  readonly payloadText?: string;
  readonly payloadJson?: JsonValue;
  readonly bytes?: number;
  readonly truncated?: boolean;
  readonly expiresAt?: Date;
}
interface TelemetryArtifactReference {
  readonly artifactId: string;
  readonly traceId?: string;
  readonly spanId?: string;
}
interface TelemetrySpanEnd {
  readonly status?: "ok" | "error";
  readonly statusMessage?: string;
  readonly endedAt?: Date;
  readonly attributes?: TelemetryAttributes;
}
interface TelemetryChildSpanStart {
  readonly name: string;
  readonly kind?: "internal" | "client";
  readonly startedAt?: Date;
  readonly attributes?: TelemetryAttributes;
}
interface TelemetryScope {
  readonly traceId?: string;
  readonly spanId?: string;
  readonly costTracking?: CostTrackingTelemetry;
  addSpanEvent(args: TelemetrySpanEventRecord): Promise<void> | void;
  recordMetric(args: TelemetryMetricRecord): Promise<void> | void;
  attachArtifact(args: TelemetryArtifactAttachment): Promise<TelemetryArtifactReference> | TelemetryArtifactReference;
}
interface TelemetrySpanScope extends TelemetryScope {
  readonly traceId: string;
  readonly spanId: string;
  end(args?: TelemetrySpanEnd): Promise<void> | void;
  asNodeTelemetry(args: Readonly<{
    nodeId: NodeId;
    activationId: NodeActivationId;
  }>): NodeExecutionTelemetry;
}
interface NodeExecutionTelemetry extends ExecutionTelemetry, TelemetrySpanScope {
  startChildSpan(args: TelemetryChildSpanStart): TelemetrySpanScope;
}
interface ExecutionTelemetry extends TelemetryScope {
  readonly traceId: string;
  readonly spanId: string;
  forNode(args: Readonly<{
    nodeId: NodeId;
    activationId: NodeActivationId;
  }>): NodeExecutionTelemetry;
}
//#endregion
//#region ../core/src/contracts/itemExpr.d.ts
type ItemExprResolvedContext = Readonly<{
  runId: RunId;
  workflowId: WorkflowId;
  nodeId: NodeId;
  activationId: NodeActivationId;
  data: RunDataSnapshot;
}>;
type ItemExprContext = ItemExprResolvedContext;
type ItemExprArgs<TItemJson = unknown> = Readonly<{
  item: Item<TItemJson>;
  itemIndex: number;
  items: Items<TItemJson>;
  ctx: ItemExprContext;
}>;
type ItemExprCallback<T, TItemJson = unknown> = (args: ItemExprArgs<TItemJson>) => T | Promise<T>;
type ItemExpr<T, TItemJson = unknown> = Readonly<{
  readonly __codemationItemExpr: "codemation.itemExpr";
  readonly fn: ItemExprCallback<T, TItemJson>;
}>;
//#endregion
//#region ../core/src/contracts/params.d.ts
type Expr<T, TItemJson = unknown> = ItemExpr<T, TItemJson>;
type ParamDeep<T, TItemJson = unknown> = Expr<T, TItemJson> | (T extends readonly (infer U)[] ? ReadonlyArray<ParamDeep<U, TItemJson>> : never) | (T extends object ? { [K in keyof T]: ParamDeep<T[K], TItemJson> } : T);
//#endregion
//#region ../core/src/contracts/retryPolicySpec.types.d.ts
type RetryPolicySpec = NoneRetryPolicySpec | FixedRetryPolicySpec | ExponentialRetryPolicySpec;
interface NoneRetryPolicySpec {
  readonly kind: "none";
}
interface FixedRetryPolicySpec {
  readonly kind: "fixed";
  readonly maxAttempts: number;
  readonly delayMs: number;
}
interface ExponentialRetryPolicySpec {
  readonly kind: "exponential";
  readonly maxAttempts: number;
  readonly initialDelayMs: number;
  readonly multiplier: number;
  readonly maxDelayMs?: number;
  readonly jitter?: boolean;
}
//#endregion
//#region ../core/src/contracts/executionPersistenceContracts.d.ts
type ExecutionInstanceId = string;
type BatchId = string;
type PersistedExecutionInstanceKind = "workflowNodeActivation" | "connectionInvocation";
type ConnectionInvocationKind = "languageModel" | "tool" | "nestedAgent";
interface WorkflowRunDetailDto {
  readonly runId: RunId;
  readonly workflowId: WorkflowId;
  readonly startedAt: string;
  readonly finishedAt?: string;
  readonly status: RunStatus;
  readonly workflowSnapshot?: PersistedWorkflowSnapshot;
  readonly mutableState?: PersistedMutableRunState;
  readonly slotStates: ReadonlyArray<SlotExecutionStateDto>;
  readonly executionInstances: ReadonlyArray<ExecutionInstanceDto>;
  readonly iterations?: ReadonlyArray<RunIterationDto>;
}
interface RunIterationDto {
  readonly iterationId: string;
  readonly agentNodeId: NodeId;
  readonly activationId: NodeActivationId;
  readonly itemIndex: number;
  readonly itemSummary?: string;
  readonly status: NodeExecutionStatus;
  readonly startedAt?: string;
  readonly finishedAt?: string;
  readonly invocationIds: ReadonlyArray<string>;
  readonly parentInvocationId?: string;
  readonly estimatedCostMinorByCurrency?: Readonly<Record<string, number>>;
  readonly estimatedCostCurrencyScaleByCurrency?: Readonly<Record<string, number>>;
}
interface SlotExecutionStateDto {
  readonly slotNodeId: NodeId;
  readonly latestInstanceId?: ExecutionInstanceId;
  readonly latestTerminalInstanceId?: ExecutionInstanceId;
  readonly latestRunningInstanceId?: ExecutionInstanceId;
  readonly status?: NodeExecutionStatus;
  readonly invocationCount: number;
  readonly runCount: number;
}
interface ExecutionInstanceDto {
  readonly instanceId: ExecutionInstanceId;
  readonly slotNodeId: NodeId;
  readonly workflowNodeId: NodeId;
  readonly parentInstanceId?: ExecutionInstanceId;
  readonly kind: PersistedExecutionInstanceKind;
  readonly connectionKind?: ConnectionInvocationKind;
  readonly runIndex: number;
  readonly batchId: BatchId;
  readonly activationId?: NodeActivationId;
  readonly status: NodeExecutionStatus;
  readonly queuedAt?: string;
  readonly startedAt?: string;
  readonly finishedAt?: string;
  readonly itemCount: number;
  readonly inputJson?: JsonValue;
  readonly outputJson?: JsonValue;
  readonly error?: Readonly<NodeExecutionError>;
  readonly iterationId?: string;
  readonly itemIndex?: number;
  readonly parentInvocationId?: string;
  readonly childRunId?: string;
}
//#endregion
//#region ../core/src/contracts/webhookTypes.d.ts
type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
interface WebhookInvocationMatch {
  endpointPath: string;
  workflowId: WorkflowId;
  nodeId: NodeId;
  methods: ReadonlyArray<HttpMethod>;
  parseJsonBody?: (body: unknown) => unknown;
}
type WebhookTriggerResolution = {
  status: "notFound";
} | {
  status: "methodNotAllowed";
  match: WebhookInvocationMatch;
} | {
  status: "ok";
  match: WebhookInvocationMatch;
};
interface WebhookTriggerMatcher {
  match(args: {
    endpointPath: string;
    method: HttpMethod;
  }): WebhookInvocationMatch | undefined;
  lookup(endpointPath: string): WebhookInvocationMatch | undefined;
  onEngineWorkflowsLoaded?(): void;
  onEngineStopped?(): void;
  reloadWebhookRoutes?(): void;
}
//#endregion
//#region ../core/src/contracts/credentialTypes.d.ts
type CredentialTypeId = string;
type CredentialInstanceId = string;
type CredentialMaterialSourceKind = "db" | "env" | "code";
type CredentialSetupStatus = "draft" | "ready";
type CredentialHealthStatus = "unknown" | "healthy" | "failing";
type CredentialFieldSchema = Readonly<{
  key: string;
  label: string;
  type: "string" | "password" | "textarea" | "json" | "boolean";
  required?: true;
  order?: number;
  visibility?: "default" | "advanced";
  placeholder?: string;
  helpText?: string;
  envVarName?: string;
  copyValue?: string;
  copyButtonLabel?: string;
}>;
type CredentialRequirement = Readonly<{
  slotKey: string;
  label: string;
  acceptedTypes: ReadonlyArray<CredentialTypeId>;
  optional?: true;
  helpText?: string;
  helpUrl?: string;
}>;
type CredentialBindingKey = Readonly<{
  workflowId: WorkflowId;
  nodeId: NodeId;
  slotKey: string;
}>;
type CredentialBinding = Readonly<{
  key: CredentialBindingKey;
  instanceId: CredentialInstanceId;
  updatedAt: string;
}>;
type CredentialHealth = Readonly<{
  status: CredentialHealthStatus;
  message?: string;
  testedAt?: string;
  expiresAt?: string;
  details?: Readonly<Record<string, unknown>>;
}>;
type OAuth2ProviderFromPublicConfig = Readonly<{
  authorizeUrlFieldKey: string;
  tokenUrlFieldKey: string;
  userInfoUrlFieldKey?: string;
}>;
type CredentialOAuth2ScopesFromPublicConfig = Readonly<{
  presetFieldKey: string;
  presetScopes: Readonly<Record<string, ReadonlyArray<string>>>;
  customPresetKey?: string;
  customScopesFieldKey?: string;
}>;
type CredentialOAuth2AuthDefinition = Readonly<{
  kind: "oauth2";
  providerId: string;
  scopes: ReadonlyArray<string>;
  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
  clientIdFieldKey?: string;
  clientSecretFieldKey?: string;
} | {
  kind: "oauth2";
  providerFromPublicConfig: OAuth2ProviderFromPublicConfig;
  scopes: ReadonlyArray<string>;
  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
  clientIdFieldKey?: string;
  clientSecretFieldKey?: string;
} | {
  kind: "oauth2";
  providerId: string;
  authorizeUrl: string;
  tokenUrl: string;
  userInfoUrl?: string;
  scopes: ReadonlyArray<string>;
  scopesFromPublicConfig?: CredentialOAuth2ScopesFromPublicConfig;
  clientIdFieldKey?: string;
  clientSecretFieldKey?: string;
}>;
type CredentialAuthDefinition = CredentialOAuth2AuthDefinition;
type CredentialAdvancedSectionPresentation = Readonly<{
  title?: string;
  description?: string;
  defaultOpen?: boolean;
}>;
type CredentialTypeDefinition = Readonly<{
  typeId: CredentialTypeId;
  displayName: string;
  description?: string;
  publicFields?: ReadonlyArray<CredentialFieldSchema>;
  secretFields?: ReadonlyArray<CredentialFieldSchema>;
  advancedSection?: CredentialAdvancedSectionPresentation;
  supportedSourceKinds?: ReadonlyArray<CredentialMaterialSourceKind>;
  auth?: CredentialAuthDefinition;
}>;
type CredentialJsonRecord = Readonly<Record<string, unknown>>;
type CredentialInstanceRecord<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
  instanceId: CredentialInstanceId;
  typeId: CredentialTypeId;
  displayName: string;
  sourceKind: CredentialMaterialSourceKind;
  publicConfig: TPublicConfig;
  secretRef: CredentialJsonRecord;
  tags: ReadonlyArray<string>;
  setupStatus: CredentialSetupStatus;
  createdAt: string;
  updatedAt: string;
  material: Readonly<{
    source: "local" | "control-plane";
    ref: string;
  }>;
}>;
type CredentialSessionFactoryArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
  instance: CredentialInstanceRecord<TPublicConfig>;
  material: TMaterial;
  publicConfig: TPublicConfig;
}>;
type CredentialSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<TSession>;
type CredentialAccessTokenSessionArgs<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord> = Readonly<{
  accessToken: string;
  grantedScopes: ReadonlyArray<string>;
  publicConfig: TPublicConfig;
}>;
type CredentialAccessTokenSessionFactory<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = (args: CredentialAccessTokenSessionArgs<TPublicConfig>) => Promise<TSession>;
type CredentialHealthTester<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord> = (args: CredentialSessionFactoryArgs<TPublicConfig, TMaterial>) => Promise<CredentialHealth>;
type CredentialType<TPublicConfig extends CredentialJsonRecord = CredentialJsonRecord, TMaterial extends CredentialJsonRecord = CredentialJsonRecord, TSession = unknown> = Readonly<{
  definition: CredentialTypeDefinition;
  createSession: CredentialSessionFactory<TPublicConfig, TMaterial, TSession>;
  createSessionFromAccessToken?: CredentialAccessTokenSessionFactory<TPublicConfig, TSession>;
  test: CredentialHealthTester<TPublicConfig, TMaterial>;
}>;
type AnyCredentialType = CredentialType<any, any, unknown>;
interface CredentialSessionService {
  getSession<TSession = unknown>(args: Readonly<{
    workflowId: WorkflowId;
    nodeId: NodeId;
    slotKey: string;
  }>): Promise<TSession>;
}
interface CredentialTypeRegistry {
  listTypes(): ReadonlyArray<CredentialTypeDefinition>;
  getType(typeId: CredentialTypeId): CredentialTypeDefinition | undefined;
}
//#endregion
//#region ../core/src/contracts/mcpTypes.d.ts
type McpServerTransport = "http";
interface McpServerDeclaration {
  id: string;
  displayName: string;
  description: string;
  transport: McpServerTransport;
  url: string;
  acceptedCredentialTypes?: ReadonlyArray<string>;
  requiredScopes?: string[];
  staticHeaders?: Record<string, string>;
  toolDescriptionOverrides?: Record<string, string>;
}
//#endregion
//#region ../core/src/contracts/collectionTypes.d.ts
interface CollectionStore<TRow extends Record<string, unknown> = Record<string, unknown>> {
  insert(row: TRow): Promise<TRow & {
    id: string;
    created_at: Date;
    updated_at: Date;
  }>;
  get(id: string): Promise<(TRow & {
    id: string;
    created_at: Date;
    updated_at: Date;
  }) | null>;
  findOne(filter: Partial<TRow>): Promise<(TRow & {
    id: string;
    created_at: Date;
    updated_at: Date;
  }) | null>;
  list(opts?: {
    limit?: number;
    offset?: number;
    where?: Partial<TRow>;
  }): Promise<{
    rows: ReadonlyArray<TRow & {
      id: string;
      created_at: Date;
      updated_at: Date;
    }>;
    total: number;
  }>;
  update(id: string, patch: Partial<TRow>): Promise<TRow & {
    id: string;
    created_at: Date;
    updated_at: Date;
  }>;
  delete(id: string): Promise<{
    deleted: boolean;
  }>;
}
type CollectionsContext = Readonly<Record<string, CollectionStore>>;
//#endregion
//#region ../core/src/contracts/workflowActivationPolicy.d.ts
interface WorkflowActivationPolicy {
  isActive(workflowId: WorkflowId): boolean;
}
//#endregion
//#region ../core/src/authoring/nodeBaseOptions.types.d.ts
interface NodeBaseOptions {
  readonly id?: string;
  readonly description?: string;
}
//#endregion
//#region ../core/src/authoring/defineNode.types.d.ts
type ResolvableCredentialType = AnyCredentialType | CredentialTypeId;
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 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, idOrOptions?: string | NodeBaseOptions): RunnableNodeConfig<TInputJson$1, TOutputJson$1>;
  register(context: {
    registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
  }): void;
}
//#endregion
//#region ../core/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$1 extends Record<string, unknown>> = TInputJson$1 & {
  readonly decision: HumanApprovalDecisionResult;
};
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> {
  readonly humanApprovalToolBehavior: {
    onRejected: "return" | "halt";
  };
}
//#endregion
//#region ../core/src/workflow/dsl/workflowBuilderTypes.d.ts
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 ../core/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$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
  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 get accumulatedEndpoints();
  private toCursor;
}
//#endregion
//#region ../core/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$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
  thenMerge<TOutputJson$1, TConfig extends RunnableNodeConfig<TCurrentJson, TOutputJson$1>>(config: TConfig): ChainCursor<TCurrentJson & RunnableNodeOutputJson<TConfig>>;
  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>;
  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;
}
//#endregion
//#region ../core/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 extends AnyTriggerNodeConfig>(config: TConfig): ChainCursor<TriggerNodeOutputJson<TConfig>>;
  start<TConfig extends AnyRunnableNodeConfig>(config: TConfig): ChainCursor<RunnableNodeOutputJson<TConfig>>;
  build(): WorkflowDefinition;
  private validateNodeIds;
}
//#endregion
//#region ../core/src/events/runEvents.d.ts
type TestCaseRunStatus = "running" | "succeeded" | "failed" | "errored" | "cancelled";
type TestSuiteRunStatus = "succeeded" | "failed" | "partial" | "errored" | "cancelled";
type RunEvent = Readonly<{
  kind: "runCreated";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
}> | Readonly<{
  kind: "runSaved";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  state: PersistedRunState;
}> | Readonly<{
  kind: "nodeQueued";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  snapshot: NodeExecutionSnapshot;
}> | Readonly<{
  kind: "nodeStarted";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  snapshot: NodeExecutionSnapshot;
}> | Readonly<{
  kind: "nodeCompleted";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  snapshot: NodeExecutionSnapshot;
}> | Readonly<{
  kind: "nodeFailed";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  snapshot: NodeExecutionSnapshot;
}> | Readonly<{
  kind: "connectionInvocationStarted";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  record: ConnectionInvocationRecord;
}> | Readonly<{
  kind: "connectionInvocationCompleted";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  record: ConnectionInvocationRecord;
}> | Readonly<{
  kind: "connectionInvocationFailed";
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  at: string;
  record: ConnectionInvocationRecord;
}> | Readonly<{
  kind: "testSuiteStarted";
  testSuiteRunId: TestSuiteRunId;
  workflowId: WorkflowId;
  triggerNodeId: string;
  triggerNodeName?: string;
  concurrency: number;
  at: string;
}> | Readonly<{
  kind: "testSuiteFinished";
  testSuiteRunId: TestSuiteRunId;
  workflowId: WorkflowId;
  status: TestSuiteRunStatus;
  totalCases: number;
  passedCases: number;
  failedCases: number;
  at: string;
}> | Readonly<{
  kind: "testCaseStarted";
  testSuiteRunId: TestSuiteRunId;
  testCaseIndex: number;
  runId: RunId;
  workflowId: WorkflowId;
  testCaseLabel?: string;
  at: string;
}> | Readonly<{
  kind: "testCaseCompleted";
  testSuiteRunId: TestSuiteRunId;
  testCaseIndex: number;
  runId: RunId;
  workflowId: WorkflowId;
  status: TestCaseRunStatus;
  at: string;
}>;
interface RunEventSubscription {
  close(): Promise<void>;
}
interface RunEventBus {
  publish(event: RunEvent): Promise<void>;
  subscribe(onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
  subscribeToWorkflow(workflowId: WorkflowId, onEvent: (event: RunEvent) => void): Promise<RunEventSubscription>;
}
//#endregion
//#region ../core/src/policies/executionLimits/EngineExecutionLimitsPolicy.d.ts
interface EngineExecutionLimitsPolicyConfig {
  readonly defaultMaxNodeActivations: number;
  readonly hardMaxNodeActivations: number;
  readonly defaultMaxSubworkflowDepth: number;
  readonly hardMaxSubworkflowDepth: number;
}
//#endregion
//#region ../core/src/contracts/runTypes.d.ts
interface RunTestContext {
  readonly testSuiteRunId: string;
  readonly testCaseIndex: number;
  readonly testCaseLabel?: string;
}
interface RunExecutionOptions {
  localOnly?: boolean;
  webhook?: boolean;
  mode?: "manual" | "debug";
  sourceWorkflowId?: WorkflowId;
  sourceRunId?: RunId;
  derivedFromRunId?: RunId;
  isMutable?: boolean;
  subworkflowDepth?: number;
  maxNodeActivations?: number;
  maxSubworkflowDepth?: number;
  testContext?: RunTestContext;
}
interface EngineRunCounters {
  completedNodeActivations: number;
}
type RunStopCondition = Readonly<{
  kind: "workflowCompleted";
}> | Readonly<{
  kind: "nodeCompleted";
  nodeId: NodeId;
}>;
interface RunStateResetRequest {
  clearFromNodeId: NodeId;
}
interface PersistedRunControlState {
  stopCondition?: RunStopCondition;
}
interface PersistedWorkflowSnapshotNode {
  id: NodeId;
  kind: NodeKind;
  name?: string;
  nodeTokenId: PersistedTokenId;
  configTokenId: PersistedTokenId;
  tokenName?: string;
  configTokenName?: string;
  config: unknown;
  inspectorSummary?: ReadonlyArray<Readonly<{
    label: string;
    value: string;
  }>>;
}
interface PersistedWorkflowSnapshot {
  id: WorkflowId;
  name: string;
  nodes: ReadonlyArray<PersistedWorkflowSnapshotNode>;
  edges: ReadonlyArray<Edge>;
  workflowErrorHandlerConfigured?: boolean;
  connections?: ReadonlyArray<WorkflowNodeConnection>;
}
type PinnedNodeOutputsByPort = Readonly<Record<OutputPortKey, Items>>;
interface PersistedMutableNodeState {
  pinnedOutputsByPort?: PinnedNodeOutputsByPort;
  lastDebugInput?: Items;
}
interface PersistedMutableRunState {
  nodesById: Readonly<Record<NodeId, PersistedMutableNodeState>>;
}
type NodeInputsByPort = Readonly<Record<InputPortKey, Items>>;
interface RunQueueEntry {
  nodeId: NodeId;
  input: Items;
  toInput?: InputPortKey;
  batchId?: string;
  from?: Readonly<{
    nodeId: NodeId;
    output: OutputPortKey;
  }>;
  collect?: Readonly<{
    expectedInputs: ReadonlyArray<InputPortKey>;
    received: Readonly<Record<InputPortKey, Items>>;
  }>;
}
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;
  stack?: string;
  details?: JsonValue;
}
interface NodeExecutionSnapshot {
  runId: RunId;
  workflowId: WorkflowId;
  nodeId: NodeId;
  activationId?: NodeActivationId;
  parent?: ParentExecutionRef;
  status: NodeExecutionStatus;
  usedPinnedOutput?: boolean;
  queuedAt?: string;
  startedAt?: string;
  finishedAt?: string;
  updatedAt: string;
  inputsByPort?: NodeInputsByPort;
  outputs?: NodeOutputs;
  error?: NodeExecutionError;
  childRunId?: RunId;
}
type ConnectionInvocationId = string;
interface ConnectionInvocationRecord {
  readonly invocationId: ConnectionInvocationId;
  readonly runId: RunId;
  readonly workflowId: WorkflowId;
  readonly connectionNodeId: NodeId;
  readonly parentAgentNodeId: NodeId;
  readonly parentAgentActivationId: NodeActivationId;
  readonly status: NodeExecutionStatus;
  readonly managedInput?: JsonValue;
  readonly managedOutput?: JsonValue;
  readonly statusLabel?: string;
  readonly subjectName?: string;
  readonly error?: NodeExecutionError;
  readonly queuedAt?: string;
  readonly startedAt?: string;
  readonly finishedAt?: string;
  readonly updatedAt: string;
  readonly iterationId?: NodeIterationId;
  readonly itemIndex?: number;
  readonly parentInvocationId?: ConnectionInvocationId;
}
type ConnectionInvocationAppendArgs = Readonly<{
  invocationId: ConnectionInvocationId;
  connectionNodeId: NodeId;
  parentAgentNodeId: NodeId;
  parentAgentActivationId: NodeActivationId;
  status: NodeExecutionStatus;
  managedInput?: JsonValue;
  managedOutput?: JsonValue;
  statusLabel?: string;
  subjectName?: string;
  error?: NodeExecutionError;
  queuedAt?: string;
  startedAt?: string;
  finishedAt?: string;
  iterationId?: NodeIterationId;
  itemIndex?: number;
  parentInvocationId?: ConnectionInvocationId;
}>;
interface RunCurrentState {
  outputsByNode: Record<NodeId, NodeOutputs>;
  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
  mutableState?: PersistedMutableRunState;
}
interface CurrentStateExecutionRequest {
  workflow: WorkflowDefinition;
  items?: Items;
  parent?: ParentExecutionRef;
  executionOptions?: RunExecutionOptions;
  workflowSnapshot?: PersistedWorkflowSnapshot;
  mutableState?: PersistedMutableRunState;
  currentState?: RunCurrentState;
  stopCondition?: RunStopCondition;
  reset?: RunStateResetRequest;
}
type RunStatus = "running" | "pending" | "completed" | "failed" | "suspended" | "halted";
type RunHaltReason = "hitl-rejected" | "hitl-timeout" | "hitl-cancelled";
interface RunSummary {
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  status: RunStatus;
  testCaseStatus?: TestCaseRunStatus;
  finishedAt?: string;
  parent?: ParentExecutionRef;
  executionOptions?: RunExecutionOptions;
}
interface PendingNodeExecution {
  runId: RunId;
  activationId: NodeActivationId;
  workflowId: WorkflowId;
  nodeId: NodeId;
  itemsIn: number;
  inputsByPort: NodeInputsByPort;
  receiptId: string;
  queue?: string;
  batchId?: string;
  enqueuedAt: string;
}
interface PersistedRunSchedulingState {
  pending?: PendingNodeExecution;
  queue: RunQueueEntry[];
}
interface PersistedSuspensionEntry {
  readonly taskId: string;
  readonly nodeId: NodeId;
  readonly activationId: NodeActivationId;
  readonly itemIndex: number;
  readonly decisionSchemaHash: string;
  readonly deliveryRef: JsonValue;
  readonly timeoutAt: string;
  readonly onTimeout: "halt" | "auto-accept";
}
interface PendingResumeEntry {
  readonly activationId: NodeActivationId;
  readonly nodeId: NodeId;
  readonly resumeContext: unknown;
}
interface PersistedRunState {
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  finishedAt?: string;
  revision?: number;
  parent?: ParentExecutionRef;
  executionOptions?: RunExecutionOptions;
  control?: PersistedRunControlState;
  workflowSnapshot?: PersistedWorkflowSnapshot;
  mutableState?: PersistedMutableRunState;
  policySnapshot?: PersistedRunPolicySnapshot;
  engineCounters?: EngineRunCounters;
  status: RunStatus;
  reason?: RunHaltReason;
  pending?: PendingNodeExecution;
  queue: RunQueueEntry[];
  outputsByNode: Record<NodeId, NodeOutputs>;
  nodeSnapshotsByNodeId: Record<NodeId, NodeExecutionSnapshot>;
  connectionInvocations?: ReadonlyArray<ConnectionInvocationRecord>;
  suspension?: ReadonlyArray<PersistedSuspensionEntry>;
  pendingResume?: PendingResumeEntry;
}
interface WorkflowExecutionRepository {
  createRun(args: {
    runId: RunId;
    workflowId: WorkflowId;
    startedAt: string;
    parent?: ParentExecutionRef;
    executionOptions?: RunExecutionOptions;
    control?: PersistedRunControlState;
    workflowSnapshot?: PersistedWorkflowSnapshot;
    mutableState?: PersistedMutableRunState;
    policySnapshot?: PersistedRunPolicySnapshot;
    engineCounters?: EngineRunCounters;
  }): Promise<void>;
  load(runId: RunId): Promise<PersistedRunState | undefined>;
  loadSchedulingState(runId: RunId): Promise<PersistedRunSchedulingState | undefined>;
  save(state: PersistedRunState): Promise<void>;
  deleteRun?(runId: RunId): Promise<void>;
}
interface RunPruneCandidate {
  readonly runId: RunId;
  readonly workflowId: WorkflowId;
  readonly startedAt: string;
  readonly finishedAt: string;
}
type RunResult = {
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  status: "completed";
  outputs: Items;
} | {
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  status: "pending";
  pending: PendingNodeExecution;
} | {
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  status: "failed";
  error: {
    message: string;
  };
} | {
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  status: "halted";
  reason: RunHaltReason;
};
type WebhookRunResult = Readonly<{
  runId: RunId;
  workflowId: WorkflowId;
  startedAt: string;
  runStatus: "pending" | "completed";
  response: Items;
}>;
interface PersistedWorkflowTokenRegistryLike {
  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): string;
  getTokenId(type: TypeToken<unknown>): string | undefined;
  resolve(tokenId: string): TypeToken<unknown> | undefined;
  registerFromWorkflows?(workflows: ReadonlyArray<WorkflowDefinition>): void;
}
//#endregion
//#region ../core/src/contracts/workflowTypes.d.ts
type NodeIdRef<TJson = unknown> = NodeId & Readonly<{
  __codemationNodeJson?: TJson;
}>;
type NodeKind = "trigger" | "node";
type JsonPrimitive = string | number | boolean | null;
interface JsonObject {
  readonly [key: string]: JsonValue;
}
type JsonValue = JsonPrimitive | JsonObject | JsonArray;
type JsonArray = ReadonlyArray<JsonValue>;
interface Edge {
  from: {
    nodeId: NodeId;
    output: OutputPortKey;
  };
  to: {
    nodeId: NodeId;
    input: InputPortKey;
  };
}
interface WorkflowNodeConnection {
  readonly parentNodeId: NodeId;
  readonly connectionName: NodeConnectionName;
  readonly childNodeIds: ReadonlyArray<NodeId>;
}
interface WorkflowDefinition {
  id: WorkflowId;
  name: string;
  nodes: NodeDefinition[];
  edges: Edge[];
  readonly connections?: ReadonlyArray<WorkflowNodeConnection>;
  discoveryPathSegments?: readonly string[];
  readonly prunePolicy?: WorkflowPrunePolicySpec;
  readonly storagePolicy?: WorkflowStoragePolicySpec;
  readonly workflowErrorHandler?: WorkflowErrorHandlerSpec;
}
interface NodeConfigBase {
  readonly kind: NodeKind;
  readonly type: TypeToken<unknown>;
  readonly name?: string;
  readonly id?: NodeId;
  readonly icon?: string;
  readonly description?: string;
  readonly execution?: Readonly<{
    hint?: "local" | "worker";
    queue?: string;
  }>;
  readonly retryPolicy?: RetryPolicySpec;
  readonly nodeErrorHandler?: NodeErrorHandlerSpec;
  readonly continueWhenEmptyOutput?: boolean;
  readonly declaredOutputPorts?: ReadonlyArray<OutputPortKey>;
  readonly declaredInputPorts?: ReadonlyArray<InputPortKey>;
  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
  readonly emitsAssertions?: true;
  inspectorSummary?(): ReadonlyArray<NodeInspectorSummaryRow> | undefined;
}
interface NodeInspectorSummaryRow {
  readonly label: string;
  readonly value: string;
}
declare const runnableNodeInputType: unique symbol;
declare const runnableNodeOutputType: unique symbol;
declare const triggerNodeOutputType: unique symbol;
interface RunnableNodeConfig<TInputJson$1 = unknown, TOutputJson$1 = unknown> extends NodeConfigBase {
  readonly kind: "node";
  readonly [runnableNodeInputType]?: TInputJson$1;
  readonly [runnableNodeOutputType]?: TOutputJson$1;
  readonly inputSchema?: ZodType<TInputJson$1>;
  readonly emptyBatchExecution?: "skip" | "runOnce";
}
declare const triggerNodeSetupStateType: unique symbol;
interface TriggerNodeConfig<TOutputJson$1 = unknown, TSetupState$1 extends JsonValue | undefined = undefined> extends NodeConfigBase {
  readonly kind: "trigger";
  readonly [triggerNodeOutputType]?: TOutputJson$1;
  readonly [triggerNodeSetupStateType]?: TSetupState$1;
  readonly triggerKind?: "live" | "test";
}
type RunnableNodeOutputJson<TConfig extends RunnableNodeConfig<any, any>> = TConfig extends RunnableNodeConfig<any, infer TOutputJson> ? TOutputJson : never;
type TriggerNodeOutputJson<TConfig extends TriggerNodeConfig<any, any>> = TConfig extends TriggerNodeConfig<infer TOutputJson, any> ? TOutputJson : never;
interface NodeDefinition {
  id: NodeId;
  kind: NodeKind;
  type: TypeToken<unknown>;
  name?: string;
  config: NodeConfigBase;
}
interface NodeRef {
  id: NodeId;
  kind: NodeKind;
  name?: string;
}
type PairedItemRef = Readonly<{
  nodeId: NodeId;
  output: OutputPortKey;
  itemIndex: number;
}>;
type BinaryPreviewKind = "image" | "audio" | "video" | "download";
type BinaryAttachment = Readonly<{
  id: string;
  storageKey: string;
  mimeType: string;
  size: number;
  storageDriver: string;
  previewKind: BinaryPreviewKind;
  createdAt: string;
  runId: RunId;
  workflowId: WorkflowId;
  nodeId: NodeId;
  activationId: NodeActivationId;
  filename?: string;
  sha256?: string;
}>;
type ItemBinary = Readonly<Record<string, BinaryAttachment>>;
type Item<TJson = unknown> = Readonly<{
  json: TJson;
  binary?: ItemBinary;
  meta?: Readonly<Record<string, unknown>>;
  paired?: ReadonlyArray<PairedItemRef>;
}>;
type Items<TJson = unknown> = ReadonlyArray<Item<TJson>>;
type NodeOutputs = Partial<Record<OutputPortKey, Items>>;
type RunId = string;
type NodeActivationId = string;
type NodeIterationId = string;
interface ParentExecutionRef {
  runId: RunId;
  workflowId: WorkflowId;
  nodeId: NodeId;
  subworkflowDepth?: number;
  engineMaxNodeActivations?: number;
  engineMaxSubworkflowDepth?: number;
  testContext?: RunTestContext;
}
interface RunDataSnapshot {
  getOutputs(nodeId: NodeId): NodeOutputs | undefined;
  getOutputItems<TJson = unknown>(nodeId: NodeId | NodeIdRef<TJson>, output?: OutputPortKey): Items<TJson>;
  getOutputItem<TJson = unknown>(nodeId: NodeId | NodeIdRef<TJson>, itemIndex: number, output?: OutputPortKey): Item<TJson> | undefined;
}
interface RunIdFactory {
  makeRunId(): RunId;
}
interface ActivationIdFactory {
  makeActivationId(): NodeActivationId;
}
type WorkflowStoragePolicyMode = "ALL" | "SUCCESS" | "ERROR" | "NEVER";
type WorkflowStoragePolicySpec = WorkflowStoragePolicyMode | TypeToken<WorkflowStoragePolicyResolver>;
interface WorkflowStoragePolicyResolver {
  shouldPersist(args: WorkflowStoragePolicyDecisionArgs): boolean | Promise<boolean>;
}
interface WorkflowStoragePolicyDecisionArgs {
  readonly runId: RunId;
  readonly workflowId: WorkflowId;
  readonly workflow: WorkflowDefinition;
  readonly finalStatus: "completed" | "failed";
  readonly startedAt: string;
  readonly finishedAt: string;
}
interface WorkflowPrunePolicySpec {
  readonly runDataRetentionSeconds?: number;
  readonly binaryRetentionSeconds?: number;
  readonly telemetrySpanRetentionSeconds?: number;
  readonly telemetryArtifactRetentionSeconds?: number;
  readonly telemetryMetricRetentionSeconds?: number;
}
interface PersistedRunPolicySnapshot {
  readonly retentionSeconds?: number;
  readonly binaryRetentionSeconds?: number;
  readonly telemetrySpanRetentionSeconds?: number;
  readonly telemetryArtifactRetentionSeconds?: number;
  readonly telemetryMetricRetentionSeconds?: number;
  readonly storagePolicy: WorkflowStoragePolicyMode;
}
interface WorkflowErrorHandler {
  onError(ctx: WorkflowErrorContext): void | Promise<void>;
}
interface WorkflowErrorContext {
  readonly runId: RunId;
  readonly workflowId: WorkflowId;
  readonly workflow: WorkflowDefinition;
  readonly failedNodeId: NodeId;
  readonly error: Error;
  readonly startedAt: string;
  readonly finishedAt: string;
}
type WorkflowErrorHandlerSpec = TypeToken<WorkflowErrorHandler> | WorkflowErrorHandler;
interface NodeErrorHandlerArgs<TConfig extends NodeConfigBase = NodeConfigBase> {
  readonly kind: "single" | "multi";
  readonly items: Items;
  readonly inputsByPort: Readonly<Record<InputPortKey, Items>> | undefined;
  readonly ctx: NodeExecutionContext<TConfig>;
  readonly error: Error;
}
interface NodeErrorHandler {
  handle<TConfig extends NodeConfigBase>(args: NodeErrorHandlerArgs<TConfig>): Promise<NodeOutputs>;
}
type NodeErrorHandlerSpec = TypeToken<NodeErrorHandler> | NodeErrorHandler;
//#endregion
//#region ../core/src/contracts/runtimeTypes.d.ts
type HumanTaskId = string;
interface HumanTaskHandle {
  readonly taskId: HumanTaskId;
  readonly runId: string;
  readonly nodeId: string;
  readonly expiresAt: Date;
  readonly resumeUrl: string;
  readonly metadata?: Readonly<Record<string, JsonValue>>;
}
interface HumanTaskActor {
  readonly actorId: string;
  readonly displayName?: string;
}
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;
}
interface WorkflowRepository {
  list(): ReadonlyArray<WorkflowDefinition>;
  get(workflowId: WorkflowId): WorkflowDefinition | undefined;
}
interface LiveWorkflowRepository extends WorkflowRepository {
  setWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
}
interface NodeExecutionStatePublisher {
  markQueued(args: {
    nodeId: NodeId;
    activationId?: NodeActivationId;
    inputsByPort?: NodeInputsByPort;
  }): Promise<void>;
  markRunning(args: {
    nodeId: NodeId;
    activationId?: NodeActivationId;
    inputsByPort?: NodeInputsByPort;
  }): Promise<void>;
  markCompleted(args: {
    nodeId: NodeId;
    activationId?: NodeActivationId;
    inputsByPort?: NodeInputsByPort;
    outputs?: NodeOutputs;
  }): Promise<void>;
  markFailed(args: {
    nodeId: NodeId;
    activationId?: NodeActivationId;
    inputsByPort?: NodeInputsByPort;
    error: Error;
  }): Promise<void>;
  appendConnectionInvocation(args: ConnectionInvocationAppendArgs): Promise<void>;
  setChildRunId?(args: {
    nodeId: NodeId;
    childRunId: RunId;
  }): Promise<void>;
}
type BinaryBody = ReadableStream<Uint8Array> | AsyncIterable<Uint8Array> | Uint8Array | ArrayBuffer;
interface BinaryStorageWriteRequest {
  storageKey: string;
  body: BinaryBody;
}
interface BinaryStorageWriteResult {
  storageKey: string;
  size: number;
  sha256?: string;
}
interface BinaryStorageReadResult {
  body: ReadableStream<Uint8Array>;
  size?: number;
}
interface BinaryStorageStatResult {
  exists: boolean;
  size?: number;
}
interface BinaryStorage {
  readonly driverName: string;
  write(args: BinaryStorageWriteRequest): Promise<BinaryStorageWriteResult>;
  openReadStream(storageKey: string): Promise<BinaryStorageReadResult | undefined>;
  stat(storageKey: string): Promise<BinaryStorageStatResult>;
  delete(storageKey: string): Promise<void>;
  deleteMany(storageKeys: ReadonlyArray<string>): Promise<void>;
  listByPrefix(prefix: string): Promise<ReadonlyArray<string>>;
}
interface BinaryAttachmentCreateRequest {
  name: string;
  body: BinaryBody;
  mimeType: string;
  filename?: string;
  previewKind?: BinaryAttachment["previewKind"];
}
interface NodeBinaryAttachmentService extends ExecutionBinaryService {
  attach(args: BinaryAttachmentCreateRequest): Promise<BinaryAttachment>;
  withAttachment<TJson>(item: Item<TJson>, name: string, attachment: BinaryAttachment): Item<TJson>;
}
interface ExecutionBinaryService {
  forNode(args: {
    nodeId: NodeId;
    activationId: NodeActivationId;
  }): NodeBinaryAttachmentService;
  openReadStream(attachment: BinaryAttachment): Promise<BinaryStorageReadResult | undefined>;
  getBytes(attachment: BinaryAttachment, maxBytes?: number): Promise<Uint8Array>;
  getText(attachment: BinaryAttachment, maxBytes?: number): Promise<string>;
  getJson<T = unknown>(attachment: BinaryAttachment, maxBytes?: number): Promise<T>;
}
interface ExecutionContext {
  runId: RunId;
  workflowId: WorkflowId;
  parent?: ParentExecutionRef;
  subworkflowDepth: number;
  engineMaxNodeActivations: number;
  engineMaxSubworkflowDepth: number;
  now: () => Date;
  data: RunDataSnapshot;
  nodeState?: NodeExecutionStatePublisher;
  telemetry: ExecutionTelemetry;
  binary: ExecutionBinaryService;
  getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
  iterationId?: NodeIterationId;
  itemIndex?: number;
  parentInvocationId?: ConnectionInvocationId;
  testContext?: RunTestContext;
  readonly collections?: CollectionsContext;
  resolve<T>(token: TypeToken<T>): T;
}
interface NodeExecutionContext<TConfig extends NodeConfigBase = NodeConfigBase> extends ExecutionContext {
  nodeId: NodeId;
  activationId: NodeActivationId;
  config: TConfig;
  telemetry: NodeExecutionTelemetry;
  binary: NodeBinaryAttachmentService;
  resumeContext?: ResumeContext;
}
interface NodeExecutionRequest {
  runId: RunId;
  activationId: NodeActivationId;
  workflowId: WorkflowId;
  nodeId: NodeId;
  input: Items;
  parent?: ParentExecutionRef;
  queue?: string;
  executionOptions?: RunExecutionOptions;
}
interface NodeExecutionScheduler {
  enqueue(request: NodeExecutionRequest): Promise<{
    receiptId: string;
  }>;
  cancel?(receiptId: string): Promise<void>;
}
interface NodeExecutionRequestHandler {
  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
}
interface NodeActivationContinuation {
  markNodeRunning(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    inputsByPort: NodeInputsByPort;
  }): Promise<void>;
  resumeFromNodeResult(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    outputs: NodeOutputs;
  }): Promise<RunResult>;
  resumeFromNodeError(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    error: Error;
  }): Promise<RunResult>;
}
interface WorkflowSnapshotResolver {
  resolve(args: {
    workflowId: WorkflowId;
    workflowSnapshot?: PersistedWorkflowSnapshot;
  }): WorkflowDefinition | undefined;
}
//#endregion
//#region ../core/src/ai/AiHost.d.ts
interface AgentCanvasPresentation<TIcon extends string = string> {
  readonly label?: string;
  readonly icon?: TIcon;
}
interface ToolConfig {
  readonly type: TypeToken<unknown>;
  readonly name: string;
  readonly description?: string;
  readonly presentation?: AgentCanvasPresentation;
  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
}
type AgentMessageRole = "system" | "user" | "assistant";
type AgentMessageBuildArgs<TInputJson$1 = unknown> = Readonly<{
  item: Item<TInputJson$1>;
  itemIndex: number;
  items: Items<TInputJson$1>;
  ctx: NodeExecutionContext<any>;
}>;
interface AgentMessageDto {
  readonly role: AgentMessageRole;
  readonly content: string;
}
type AgentMessageTemplateContent<TInputJson$1 = unknown> = string | ((args: AgentMessageBuildArgs<TInputJson$1>) => string);
interface AgentMessageTemplate<TInputJson$1 = unknown> {
  readonly role: AgentMessageRole;
  readonly content: AgentMessageTemplateContent<TInputJson$1>;
}
type AgentMessageLine<TInputJson$1 = unknown> = AgentMessageDto | AgentMessageTemplate<TInputJson$1>;
type AgentMessageConfig<TInputJson$1 = unknown> = Expr<ReadonlyArray<AgentMessageLine<TInputJson$1>>, TInputJson$1> | ReadonlyArray<AgentMessageLine<TInputJson$1>> | {
  readonly prompt?: ReadonlyArray<AgentMessageLine<TInputJson$1>>;
  readonly buildMessages?: (args: AgentMessageBuildArgs<TInputJson$1>) => ReadonlyArray<AgentMessageDto>;
};
type AgentTurnLimitBehavior = "error" | "respondWithLastMessage";
interface AgentModelInvocationOptions {
  readonly maxTokens?: number;
  readonly providerOptions?: Readonly<Record<string, JsonValue>>;
}
interface AgentGuardrailConfig {
  readonly maxTurns?: number;
  readonly onTurnLimitReached?: AgentTurnLimitBehavior;
  readonly modelInvocationOptions?: AgentModelInvocationOptions;
}
interface ChatModelConfig {
  readonly type: TypeToken<ChatModelFactory<ChatModelConfig>>;
  readonly name: string;
  readonly provider?: string;
  readonly modelName?: string;
  readonly presentation?: AgentCanvasPresentation;
  getCredentialRequirements?(): ReadonlyArray<CredentialRequirement>;
}
interface ChatLanguageModel {
  readonly languageModel: unknown;
  readonly modelName: string;
  readonly provider?: string;
  readonly defaultCallOptions?: ChatLanguageModelCallOptions;
}
interface ChatLanguageModelCallOptions {
  readonly maxOutputTokens?: number;
  readonly temperature?: number;
  readonly providerOptions?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
}
interface ChatModelFactory<TConfig extends ChatModelConfig = ChatModelConfig> {
  create(args: Readonly<{
    config: TConfig;
    ctx: NodeExecutionContext<any>;
  }>): Promise<ChatLanguageModel> | ChatLanguageModel;
}
//#endregion
export { RunEventBus as $, RunId as A, WorkflowRunDetailDto as At, RunExecutionOptions as B, JsonValue as C, CredentialTypeDefinition as Ct, NodeOutputs as D, WebhookInvocationMatch as Dt, NodeInspectorSummaryRow as E, HttpMethod as Et, CurrentStateExecutionRequest as F, NodeId as Ft, RunSummary as G, RunResult as H, NodeInputsByPort as I, WorkflowId as It, Container as J, WebhookRunResult as K, PersistedRunState as L, RunnableNodeConfig as M, TelemetryAttributes as Mt, RunnableNodeOutputJson as N, TelemetryMetricRecord as Nt, ParentExecutionRef as O, WebhookTriggerMatcher as Ot, WorkflowDefinition as P, TelemetrySpanEventRecord as Pt, RunEvent as Q, PersistedWorkflowTokenRegistryLike as R, Items as S, CredentialType as St, NodeDefinition as T, CredentialTypeRegistry as Tt, RunStatus as U, RunPruneCandidate as V, RunStopCondition as W, TypeToken as X, DependencyContainer as Y, EngineExecutionLimitsPolicyConfig as Z, WorkflowRepository as _, CredentialOAuth2AuthDefinition as _t, BinaryBody as a, DefinedNodeConfigInput as at, BinaryAttachment as b, CredentialSessionService as bt, BinaryStorageStatResult as c, AnyCredentialType as ct, NodeActivationContinuation as d, CredentialFieldSchema as dt, TestCaseRunStatus as et, NodeExecutionContext as f, CredentialHealth as ft, ResumeContext as g, CredentialMaterialSourceKind as gt, NodeExecutionScheduler as h, CredentialJsonRecord as ht, ToolConfig as i, DefinedNode as it, RunIdFactory as j, TelemetryArtifactAttachment as jt, PersistedRunPolicySnapshot as k, WebhookTriggerResolution as kt, BinaryStorageWriteResult as l, CredentialBinding as lt, NodeExecutionRequestHandler as m, CredentialInstanceRecord as mt, AgentMessageConfig as n, ChainCursor as nt, BinaryStorage as o, WorkflowActivationPolicy as ot, NodeExecutionRequest as p, CredentialInstanceId as pt, WorkflowExecutionRepository as q, ChatModelConfig as r, AnyRunnableNodeConfig as rt, BinaryStorageReadResult as s, McpServerDeclaration as st, AgentGuardrailConfig as t, TestSuiteRunStatus as tt, LiveWorkflowRepository as u, CredentialBindingKey as ut, WorkflowSnapshotResolver as v, CredentialRequirement as vt, NodeActivationId as w, CredentialTypeId as wt, Item as x, CredentialSetupStatus as xt, ActivationIdFactory as y, CredentialSessionFactoryArgs as yt, RunCurrentState as z };
//# sourceMappingURL=ItemsInputNormalizer-C2gLv7d9.d.ts.map