import { $n as NodeActivationContinuation, $t as RunId, B as WorkflowExecutionListingRepository, Bn as EngineDeps, Br as WebhookTriggerRoutingDiagnostics, C as PersistedWorkflowSnapshotNode, Ct as ExecutionMode, Et as Items, Ft as NodeDefinition, H as WorkflowExecutionRepository, Hr as WorkflowActivationPolicy, It as NodeErrorHandler, Jt as ParentExecutionRef, Kt as NodeSchedulerDecision, L as RunSummary, Lr as WebhookInvocationMatch, N as RunResult, Nt as NodeActivationId, Or as WorkflowNodeInstanceFactory, Pr as HttpMethod, Pt as NodeConfigBase, Qi as NodeId, Qr as TelemetryScope, Rr as WebhookTriggerMatcher, Rt as NodeErrorHandlerSpec, Ur as ExecutionTelemetry, Ut as NodeOffloadPolicy, V as WorkflowExecutionPruneRepository, W as DependencyContainer, Wt as NodeOutputs, Y as TypeToken, Yt as PersistedRunPolicySnapshot, _n as WorkflowStoragePolicyDecisionArgs, b as PersistedRunState, c as EngineRunCounters, cn as WorkflowDefinition, cr as NodeExecutionScheduler, ct as ENGINE_EXECUTION_LIMITS_DEFAULTS, dn as WorkflowErrorHandlerSpec, dr as NodeResolver, ea as PersistedTokenId, fi as CostTrackingTelemetry, ft as RunEventBus, gi as CostTrackingUsageRecord, gt as TestSuiteRunId, hn as WorkflowPolicyRuntimeDefaults, ht as TestSuiteRunStatus, j as RunPruneCandidate, k as RunExecutionOptions, kr as WorkflowRepository, lt as EngineExecutionLimitsPolicy, mi as CostTrackingTelemetryFactory, mr as PreparedNodeActivationDispatch, mt as TestCaseRunStatus, or as NodeExecutionRequest, rr as NodeActivationScheduler, ta as WorkflowId, tr as NodeActivationRequest, un as WorkflowErrorHandler, ut as EngineExecutionLimitsPolicyConfig, vr as SuspensionRequest, y as PersistedRunSchedulingState } from "../agentMcpTypes-BHX4RQCC.cjs";
import { n as CostCatalogEntry, t as CostCatalog } from "../CostCatalogContract-Dwo-ZamG.cjs";
import { n as InMemoryLiveWorkflowRepository, r as Engine, t as RunIntentService } from "../RunIntentService-DKxuHTUz.cjs";
import { a as ItemExprResolver, c as DefaultAsyncSleeper, d as UnavailableBinaryStorage, f as HitlResumeTokenSignerSeam, i as RunnableOutputBehaviorResolver, l as AsyncSleeper, m as HitlTimeoutJobSchedulerSeam, n as InMemoryBinaryStorage, o as InProcessRetryRunner, s as DefaultExecutionContextFactory, t as InMemoryRunDataFactory, u as DefaultExecutionBinaryService, x as CredentialResolverFactory, y as HumanTaskStore } from "../InMemoryRunDataFactory-D2U9azmZ.cjs";
import { a as WorkflowSnapshotCodec, i as EngineWorkflowRunnerService, n as TriggerRuntimeDiagnosticsProvider, r as WebhookTriggerMatcherProvider, t as EngineRuntimeRegistrationOptions } from "../EngineRuntimeRegistration.types-BiNasx3G.cjs";

//#region src/orchestration/AbortControllerFactory.d.ts
declare class AbortControllerFactory {
  create(): AbortController;
}
//#endregion
//#region src/policies/storage/WorkflowStoragePolicyEvaluator.d.ts
declare class WorkflowStoragePolicyEvaluator {
  private readonly nodeResolver;
  constructor(nodeResolver: NodeResolver);
  shouldPersist(workflow: WorkflowDefinition, snapshot: PersistedRunPolicySnapshot | undefined, args: WorkflowStoragePolicyDecisionArgs): Promise<boolean>;
  private modeMatches;
}
//#endregion
//#region src/policies/storage/RunTerminalPersistenceCoordinator.d.ts
declare class RunTerminalPersistenceCoordinator {
  private readonly runRepository;
  private readonly storageEvaluator;
  constructor(runRepository: WorkflowExecutionRepository, storageEvaluator: WorkflowStoragePolicyEvaluator);
  maybeDeleteAfterTerminalState(args: {
    workflow: WorkflowDefinition;
    state: PersistedRunState;
    finalStatus: "completed" | "failed";
    finishedAt: string;
  }): Promise<void>;
}
//#endregion
//#region src/policies/WorkflowPolicyErrorServices.d.ts
declare class WorkflowPolicyErrorServices {
  private readonly nodeResolver;
  constructor(nodeResolver: NodeResolver);
  resolveNodeErrorHandler(spec: NodeErrorHandlerSpec | undefined): NodeErrorHandler | undefined;
  resolveWorkflowErrorHandler(spec: WorkflowErrorHandlerSpec | undefined): WorkflowErrorHandler | undefined;
}
//#endregion
//#region src/workflowSnapshots/MissingRuntimeExecutionMarker.d.ts
declare class MissingRuntimeExecutionMarker {
  isMarked(config: unknown): boolean;
}
//#endregion
//#region src/execution/CatalogBackedCostTrackingTelemetryFactory.d.ts
declare class CatalogBackedCostTrackingTelemetryFactory implements CostTrackingTelemetryFactory {
  private readonly costCatalog;
  constructor(costCatalog: CostCatalog);
  create(args: Readonly<{
    telemetry: ExecutionTelemetry;
  }>): CostTrackingTelemetry;
}
//#endregion
//#region src/execution/NodeSuspensionHandler.d.ts
declare class NodeSuspensionHandler {
  private readonly workflowExecutionRepository;
  private readonly humanTaskStore?;
  private readonly tokenSigner?;
  private readonly timeoutScheduler?;
  private readonly workspaceId?;
  constructor(workflowExecutionRepository: WorkflowExecutionRepository, humanTaskStore?: HumanTaskStore | undefined, tokenSigner?: HitlResumeTokenSignerSeam | undefined, timeoutScheduler?: HitlTimeoutJobSchedulerSeam | undefined, workspaceId?: string | undefined);
  handle(args: {
    runId: RunId;
    nodeId: NodeId;
    activationId: NodeActivationId;
    itemIndex: number;
    suspensionRequest: SuspensionRequest;
    state: PersistedRunState;
    telemetry?: TelemetryScope;
  }): Promise<never>;
  private parseDurationMs;
  private hashSchema;
  private schemaToJson;
}
//#endregion
//#region src/execution/NodeExecutor.d.ts
declare class NodeExecutor {
  private readonly nodeInstanceFactory;
  private readonly retryRunner;
  private readonly suspensionHandler?;
  private readonly loadRunState?;
  private readonly fanInMerger;
  private readonly outputNormalizer;
  private readonly itemExprResolver;
  private readonly outputBehaviorResolver;
  constructor(nodeInstanceFactory: WorkflowNodeInstanceFactory, retryRunner: InProcessRetryRunner, itemExprResolver?: ItemExprResolver, outputBehaviorResolver?: RunnableOutputBehaviorResolver, suspensionHandler?: NodeSuspensionHandler | undefined, loadRunState?: ((runId: RunId) => Promise<PersistedRunState | undefined>) | undefined);
  execute(request: NodeActivationRequest): Promise<NodeOutputs>;
  private assertRequiredCredentialsBound;
  private isCredentialError;
  private executeMultiInputActivation;
  private executeSingleInputNode;
  private isTriggerNode;
  private isRunnableNode;
  private hasExecuteMulti;
  private asMultiFromSingleActivation;
  private executeRunnableActivation;
  private pickExecutionContext;
  private resolveInputSchema;
  private assertItemJsonNotTopLevelArray;
  private assertNoPortEnvelopeBypass;
}
//#endregion
//#region src/execution/NodeInstanceFactory.d.ts
declare class NodeInstanceFactory implements WorkflowNodeInstanceFactory {
  private readonly nodeResolver;
  constructor(nodeResolver: NodeResolver);
  createNodes(workflow: WorkflowDefinition): Map<NodeId, unknown>;
  createNode(definition: WorkflowDefinition["nodes"][number]): unknown;
  createByType(type: TypeToken<unknown>): unknown;
}
//#endregion
//#region src/execution/StaticCostCatalog.d.ts
declare class StaticCostCatalog implements CostCatalog {
  private readonly entriesByKey;
  constructor(entries: ReadonlyArray<CostCatalogEntry>);
  findEntry(args: CostTrackingUsageRecord): CostCatalogEntry | undefined;
  private createKeyFromEntry;
  private createKeyFromUsage;
}
//#endregion
//#region src/scheduler/ConfigDrivenOffloadPolicy.d.ts
declare class ConfigDrivenOffloadPolicy implements NodeOffloadPolicy {
  private readonly defaultMode;
  constructor(defaultMode?: ExecutionMode);
  decide(args: {
    workflowId: WorkflowId;
    nodeId: NodeId;
    config: NodeConfigBase;
  }): NodeSchedulerDecision;
}
//#endregion
//#region src/scheduler/InlineDrivingScheduler.d.ts
declare class InlineDrivingScheduler implements NodeActivationScheduler {
  private readonly nodeExecutor;
  private continuation;
  private readonly drainingRuns;
  private readonly queuesByRunId;
  private readonly scheduledRuns;
  private stopped;
  private readonly activeDrainPromises;
  constructor(nodeExecutor: NodeExecutor);
  setContinuation(continuation: NodeActivationContinuation): void;
  stop(): Promise<void>;
  prepareDispatch(request: NodeActivationRequest): Promise<PreparedNodeActivationDispatch>;
  private drainRun;
  private scheduleDrain;
  private resumeAfterExecutionResult;
  private resumeAfterExecutionError;
  private asError;
  private rethrowUnlessIgnorableContinuationError;
  private isIgnorableContinuationError;
}
//#endregion
//#region src/scheduler/DefaultDrivingScheduler.d.ts
declare class DefaultDrivingScheduler implements NodeActivationScheduler {
  private readonly offloadPolicy;
  private readonly workerScheduler;
  private readonly inline;
  constructor(offloadPolicy: NodeOffloadPolicy, workerScheduler: NodeExecutionScheduler, inline: InlineDrivingScheduler);
  setContinuation(continuation: NodeActivationContinuation): void;
  prepareDispatch(request: NodeActivationRequest): Promise<PreparedNodeActivationDispatch>;
  private selectScheduler;
  private hasNodeSchedulingPreference;
  private prepareInlineDispatch;
}
//#endregion
//#region src/scheduler/HintOnlyOffloadPolicy.d.ts
declare class HintOnlyOffloadPolicy implements NodeOffloadPolicy {
  decide(args: {
    workflowId: WorkflowId;
    nodeId: NodeId;
    config: NodeConfigBase;
  }): NodeSchedulerDecision;
}
//#endregion
//#region src/scheduler/LocalOnlyScheduler.d.ts
declare class LocalOnlyScheduler implements NodeExecutionScheduler {
  enqueue(_request: NodeExecutionRequest): Promise<{
    receiptId: string;
  }>;
}
//#endregion
//#region src/policies/executionLimits/EngineExecutionLimitsPolicyFactory.d.ts
declare class EngineExecutionLimitsPolicyFactory {
  create(overrides?: Partial<EngineExecutionLimitsPolicyConfig>): EngineExecutionLimitsPolicy;
}
//#endregion
//#region src/policies/storage/RunPolicySnapshotFactory.d.ts
declare class RunPolicySnapshotFactory {
  static create(workflow: WorkflowDefinition, defaults?: WorkflowPolicyRuntimeDefaults): PersistedRunPolicySnapshot;
}
//#endregion
//#region src/runStorage/InMemoryWorkflowExecutionRepository.d.ts
declare class InMemoryWorkflowExecutionRepository implements WorkflowExecutionRepository, WorkflowExecutionListingRepository, WorkflowExecutionPruneRepository {
  private readonly runs;
  createRun(args: {
    runId: RunId;
    workflowId: WorkflowId;
    startedAt: string;
    parent?: ParentExecutionRef;
    executionOptions?: PersistedRunState["executionOptions"];
    control?: PersistedRunState["control"];
    workflowSnapshot?: PersistedRunState["workflowSnapshot"];
    mutableState?: PersistedRunState["mutableState"];
    policySnapshot?: PersistedRunState["policySnapshot"];
    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>;
  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/runStorage/RunSummaryMapper.d.ts
declare class RunSummaryMapper {
  static fromPersistedState(state: PersistedRunState): RunSummary;
}
//#endregion
//#region src/workflowSnapshots/MissingRuntimeFallbacksFactory.d.ts
declare class MissingRuntimeFallbacks {
  createDefinition(snapshotNode: PersistedWorkflowSnapshotNode): NodeDefinition;
}
//#endregion
//#region src/runtime/EngineFactory.d.ts
type EngineCompositionDeps = EngineDeps & {
  workflowSnapshotCodec?: WorkflowSnapshotCodec;
  missingRuntimeFallbacks?: MissingRuntimeFallbacks;
  executionLimitsPolicy?: EngineExecutionLimitsPolicy;
};
declare class EngineFactory {
  create(deps: EngineCompositionDeps): Engine;
}
//#endregion
//#region src/runtime/WorkflowRepositoryWebhookTriggerMatcher.d.ts
declare class WorkflowRepositoryWebhookTriggerMatcher implements WebhookTriggerMatcher {
  private readonly workflowRepository;
  private readonly workflowActivationPolicy;
  private readonly diagnostics?;
  private readonly routeByPath;
  private engineRoutesActive;
  constructor(workflowRepository: WorkflowRepository, workflowActivationPolicy: WorkflowActivationPolicy, diagnostics?: WebhookTriggerRoutingDiagnostics | undefined);
  onEngineWorkflowsLoaded(): void;
  onEngineStopped(): void;
  reloadWebhookRoutes(): void;
  lookup(endpointPath: string): WebhookInvocationMatch | undefined;
  match(args: {
    endpointPath: string;
    method: HttpMethod;
  }): WebhookInvocationMatch | undefined;
  private rebuildRouteIndex;
  private collectWebhookEndpointPaths;
  private tryMatchFromTriggerNode;
  private normalizeEndpointPath;
}
//#endregion
//#region src/workflowSnapshots/MissingRuntimeParityGuard.d.ts
declare class MissingRuntimeParityGuard {
  private readonly marker;
  constructor(marker: MissingRuntimeExecutionMarker);
  assertNone(workflow: WorkflowDefinition, nodeIds?: ReadonlyArray<NodeId>): void;
}
//#endregion
//#region src/orchestration/TestSuiteRunIdFactory.d.ts
declare class TestSuiteRunIdFactory {
  makeTestSuiteRunId(): TestSuiteRunId;
}
//#endregion
//#region src/orchestration/TestSuiteOrchestrator.d.ts
interface TestSuiteOrchestratorEngine {
  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions): Promise<RunResult>;
  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
    status: "completed" | "failed" | "halted";
  }>>;
}
interface TestSuiteCaseOutcome {
  readonly testCaseIndex: number;
  readonly runId: RunId;
  readonly status: TestCaseRunStatus;
}
interface TestSuiteRunResult {
  readonly testSuiteRunId: TestSuiteRunId;
  readonly workflowId: WorkflowId;
  readonly triggerNodeId: NodeId;
  readonly status: TestSuiteRunStatus;
  readonly totalCases: number;
  readonly passedCases: number;
  readonly failedCases: number;
  readonly cases: ReadonlyArray<TestSuiteCaseOutcome>;
}
interface RunTestSuiteArgs {
  readonly workflow: WorkflowDefinition;
  readonly triggerNodeId: NodeId;
  readonly testSuiteRunId?: TestSuiteRunId;
  readonly concurrency?: number;
  readonly signal?: AbortSignal;
}
declare class TestSuiteOrchestrator {
  private readonly engine;
  private readonly testSuiteRunIdFactory;
  private readonly credentialResolverFactory;
  private readonly abortControllerFactory;
  private readonly eventBus;
  private readonly currentDate;
  constructor(engine: TestSuiteOrchestratorEngine, testSuiteRunIdFactory: TestSuiteRunIdFactory, credentialResolverFactory: CredentialResolverFactory, abortControllerFactory: AbortControllerFactory, eventBus: RunEventBus | undefined, currentDate?: () => Date);
  runSuite(args: RunTestSuiteArgs): Promise<TestSuiteRunResult>;
  private runOneCase;
  private deriveSuiteStatus;
  private now;
  private resolveCaseLabel;
  private publish;
}
//#endregion
//#region src/bootstrap/runtime/EngineRuntimeRegistrar.d.ts
declare class EngineRuntimeRegistrar {
  register(container: DependencyContainer, options?: EngineRuntimeRegistrationOptions): void;
  private registerAgentMcpIntegration;
  private registerSupportFactories;
  private registerExecutionLimitsPolicy;
  private ensureWorkflowNodeInstanceFactory;
  private ensureNodeExecutor;
  private registerDefaultActivationScheduler;
  private registerEngine;
  private registerIntentServices;
  private resolveMatcherProvider;
}
//#endregion
//#region src/workflowSnapshots/MissingRuntimeTriggerToken.d.ts
declare class MissingRuntimeTriggerToken {}
//#endregion
//#region src/workflowSnapshots/PersistedWorkflowTokenRegistry.d.ts
declare class PersistedWorkflowTokenRegistry {
  private readonly tokensById;
  private readonly tokenIdsByToken;
  register(type: TypeToken<unknown>, packageId: string, persistedNameOverride?: string): PersistedTokenId;
  registerFromWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
  private registerDecoratedType;
  private registerNestedTypes;
  private displayNameForTypeToken;
  private asTypeToken;
  getTokenId(token: TypeToken<unknown>): PersistedTokenId | undefined;
  resolve(tokenId: PersistedTokenId): TypeToken<unknown> | undefined;
}
//#endregion
//#region src/workflowSnapshots/WorkflowParityMismatchError.d.ts
type MissingRuntimeNodeDetail = {
  nodeId: NodeId;
  kind: "node" | "trigger";
  missingTokenId: string | undefined;
};
declare class WorkflowParityMismatchError extends Error {
  readonly name = "WorkflowParityMismatchError";
  readonly missingNodes: ReadonlyArray<MissingRuntimeNodeDetail>;
  constructor(missingNodes: ReadonlyArray<MissingRuntimeNodeDetail>);
}
//#endregion
export { AbortControllerFactory, type AsyncSleeper, CatalogBackedCostTrackingTelemetryFactory, ConfigDrivenOffloadPolicy, CredentialResolverFactory, DefaultAsyncSleeper, DefaultDrivingScheduler, DefaultExecutionBinaryService, DefaultExecutionContextFactory, ENGINE_EXECUTION_LIMITS_DEFAULTS, Engine, type EngineCompositionDeps, EngineExecutionLimitsPolicy, type EngineExecutionLimitsPolicyConfig, EngineExecutionLimitsPolicyFactory, EngineFactory, EngineRuntimeRegistrar, type EngineRuntimeRegistrationOptions, EngineWorkflowRunnerService, HintOnlyOffloadPolicy, InMemoryBinaryStorage, InMemoryLiveWorkflowRepository, InMemoryRunDataFactory, InMemoryWorkflowExecutionRepository, InProcessRetryRunner, InlineDrivingScheduler, LocalOnlyScheduler, type MissingRuntimeNodeDetail, MissingRuntimeParityGuard, MissingRuntimeTriggerToken, NodeExecutor, NodeInstanceFactory, PersistedWorkflowTokenRegistry, RunIntentService, RunPolicySnapshotFactory, RunSummaryMapper, RunTerminalPersistenceCoordinator, type RunTestSuiteArgs, StaticCostCatalog, type TestSuiteCaseOutcome, TestSuiteOrchestrator, type TestSuiteOrchestratorEngine, TestSuiteRunIdFactory, type TestSuiteRunResult, type TriggerRuntimeDiagnosticsProvider, UnavailableBinaryStorage, type WebhookTriggerMatcherProvider, WorkflowParityMismatchError, WorkflowPolicyErrorServices, WorkflowRepositoryWebhookTriggerMatcher, WorkflowSnapshotCodec, WorkflowStoragePolicyEvaluator };
//# sourceMappingURL=index.d.cts.map