import { $i as NodeExecutionContext, $t as ConnectionInvocationId, Ai as BinaryStorageStatResult, Ao as CredentialRequirement, Bi as HumanTaskActor, Br as NodeSchedulerDecision, Ca as WorkflowRepository, Cn as RunExecutionOptions, Cr as JsonObject, Di as BinaryBody, Dn as RunResult, Dr as NodeActivationId, Eo as CredentialJsonRecord, Er as MutableRunData, Fn as WorkflowExecutionPruneRepository, Fo as CredentialType, Gr as RunDataFactory, Ho as PollingTriggerLogger, Hr as ParentExecutionRef, Ia as WorkflowActivationPolicy, In as WorkflowExecutionRepository, Io as CredentialTypeDefinition, Ka as TelemetryScope, Ko as NodeId, Kr as RunDataSnapshot, L as NodeBaseOptions, La as ExecutionTelemetry, Li as ExecutionBinaryService, Lr as NodeOffloadPolicy, Ma as WebhookTriggerMatcher, Mi as BinaryStorageWriteResult, Mn as RunTestContext, Mo as CredentialSessionFactoryArgs, N as DefinedNodeCredentialBindings, No as CredentialSessionService, Oa as HttpMethod, Oi as BinaryStorage, Or as NodeConfigBase, Pa as WebhookTriggerRoutingDiagnostics, Pi as EngineDeps, Pn as WorkflowExecutionListingRepository, Pr as NodeInspectorSummaryRow, Qi as NodeBinaryAttachmentService, Qr as TriggerNodeConfig, Ra as ExecutionTelemetryFactory, Ri as ExecutionContext, Rr as NodeOutputs, Sa as WorkflowNodeInstanceFactory, Tn as RunPruneCandidate, Tr as JsonValue, Tt as CostCatalogEntry, Ui as HumanTaskSubject, Un as TypeToken, Ur as PersistedRunPolicySnapshot, Vi as HumanTaskHandle, Wr as PollingTriggerConfig, Ya as TelemetrySpanScope, Yi as NodeActivationRequest, Yo as WorkflowId, Yr as RunnableNodeConfig, Zi as NodeActivationScheduler, _n as PersistedWorkflowSnapshotNode, _r as ExecutionMode, aa as NodeResolver, an as NodeExecutionSnapshot, ar as RunEvent, ba as TriggerSetupStateRepository, bo as CredentialFieldSchema, br as Items, ca as PreparedNodeActivationDispatch, co as CostTrackingTelemetryFactory, cr as TestCaseRunStatus, ea as NodeExecutionRequest, en as ConnectionInvocationRecord, fa as SuspensionRequest, fo as CollectionsContext, gr as Edge, j as DefinedNodeCredentialAccessors, ja as WebhookInvocationMatch, jn as RunSummary, k as DefinedNode, ka as TriggerInstanceId, ki as BinaryStorageReadResult, kr as NodeDefinition, lr as TestSuiteRunStatus, mn as PersistedRunState, mr as BinaryAttachment, na as NodeExecutionScheduler, ni as WorkflowDefinition, nn as EngineRunCounters, oo as CostTrackingTelemetry, or as RunEventBus, pn as PersistedRunSchedulingState, pr as ActivationIdFactory, qi as NodeActivationContinuation, qo as OutputPortKey, qr as RunId, ra as NodeExecutionStatePublisher, rr as EngineExecutionLimitsPolicy, sr as RunEventSubscription, uo as CostTrackingUsageRecord, ur as TestSuiteRunId, vr as Item, wi as RetryPolicySpec, wt as CostCatalog, xa as TriggerTestItemsContext, xo as CredentialHealth, zi as ExecutionContextFactory } from "./index-CRv3_pY3.js";
import { i as WorkflowSnapshotCodec, u as Engine } from "./RunIntentService-DrpKli2k.js";
import { B as ZodSchemaAny, K as CallableToolConfig, q as CallableToolConfigOptions } from "./ItemsInputNormalizer-D2vrMrX1.js";
import { ZodType, z } from "zod";

//#region src/orchestration/AbortControllerFactory.d.ts
declare class AbortControllerFactory {
  create(): AbortController;
}
//#endregion
//#region src/execution/CredentialResolverFactory.d.ts
declare class CredentialResolverFactory {
  private readonly credentialSessions;
  constructor(credentialSessions: CredentialSessionService);
  create(workflowId: WorkflowId, nodeId: NodeId, config?: NodeExecutionContext["config"]): NodeExecutionContext["getCredential"];
}
//#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/workflowSnapshots/MissingRuntimeExecutionMarker.d.ts
declare class MissingRuntimeExecutionMarker {
  isMarked(config: unknown): boolean;
}
//#endregion
//#region src/contracts/Clock.d.ts
interface Clock {
  now(): Date;
}
declare class SystemClock implements Clock {
  now(): Date;
}
//#endregion
//#region src/contracts/humanTaskStoreTypes.d.ts
type HumanTaskStatus = "pending" | "decided" | "timed_out" | "auto_accepted" | "cancelled";
interface HumanTaskRecord {
  readonly id: string;
  readonly runId: string;
  readonly workflowId: string;
  readonly workspaceId?: string;
  readonly nodeId: string;
  readonly activationId: string;
  readonly itemIndex: number;
  readonly status: HumanTaskStatus;
  readonly channel: string;
  readonly subject: HumanTaskSubject;
  readonly metadata: Record<string, JsonValue>;
  readonly decisionSchemaJson: string;
  readonly decisionSchemaHash: string;
  readonly onTimeout: "halt" | "auto-accept";
  readonly deliveryRef?: JsonValue;
  readonly decision?: JsonValue;
  readonly decidedAt?: Date;
  readonly decidedBy?: HumanTaskActor;
  readonly resumeTokenHash: string;
  readonly expiresAt: Date;
  readonly createdAt: Date;
}
interface HumanTaskStore {
  create(record: HumanTaskRecord): Promise<void>;
  findById(taskId: string): Promise<HumanTaskRecord | undefined>;
  findByResumeTokenHash(tokenHash: string): Promise<HumanTaskRecord | undefined>;
  findPendingForWorkspace(workspaceId: string): Promise<ReadonlyArray<HumanTaskRecord>>;
  findAllPending(): Promise<ReadonlyArray<HumanTaskRecord>>;
  markDecided(args: {
    taskId: string;
    decision: JsonValue;
    decidedBy: HumanTaskActor;
    decidedAt: Date;
  }): Promise<void>;
  markTimedOut(taskId: string): Promise<void>;
  markAutoAccepted(taskId: string): Promise<void>;
  markCancelled(taskId: string): Promise<void>;
  cancelPendingForRun(runId: string): Promise<void>;
}
declare const HumanTaskStoreToken: TypeToken<HumanTaskStore | undefined>;
//#endregion
//#region src/contracts/hitlSeamTypes.d.ts
interface HitlResumeTokenSignerSeam {
  sign(args: {
    taskId: string;
    expiresAt: Date;
    schemaHash: string;
  }): string;
  hashToken(token: string): string;
}
interface HitlTimeoutJobSchedulerSeam {
  enqueueTimeoutJob(args: {
    taskId: string;
    expiresAt: Date;
  }): Promise<void>;
}
declare const HitlResumeTokenSignerToken: TypeToken<HitlResumeTokenSignerSeam | undefined>;
declare const HitlTimeoutJobSchedulerToken: TypeToken<HitlTimeoutJobSchedulerSeam | undefined>;
declare const HitlWorkspaceIdToken: TypeToken<string | undefined>;
//#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 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly key: TKey;
  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 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined> {
  readonly kind: "defined-polling-trigger";
  readonly key: TKey;
  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 extends string, TConfig$1 extends CredentialJsonRecord, TItemJson, TState extends JsonValue | undefined, TBindings extends DefinedNodeCredentialBindings | undefined = undefined>(options: DefinePollingTriggerOptions<TKey, TConfig$1, TItemJson, TState, TBindings>): DefinedPollingTrigger<TKey, 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/binaries/UnavailableBinaryStorage.d.ts
declare class UnavailableBinaryStorage implements BinaryStorage {
  readonly driverName = "unavailable";
  write(): Promise<never>;
  openReadStream(): Promise<undefined>;
  stat(): Promise<{
    exists: false;
  }>;
  delete(): Promise<void>;
  deleteMany(): Promise<void>;
  listByPrefix(): Promise<ReadonlyArray<string>>;
}
//#endregion
//#region src/binaries/DefaultExecutionBinaryServiceFactory.d.ts
declare class DefaultExecutionBinaryService implements ExecutionBinaryService {
  private readonly storage;
  private readonly workflowId;
  private readonly runId;
  private readonly now;
  constructor(storage: BinaryStorage, workflowId: WorkflowId, runId: RunId, now: () => Date);
  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>;
}
//#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/asyncSleeper.types.d.ts
interface AsyncSleeper {
  sleep(ms: number): Promise<void>;
}
//#endregion
//#region src/execution/DefaultAsyncSleeper.d.ts
declare class DefaultAsyncSleeper implements AsyncSleeper {
  sleep(ms: number): Promise<void>;
}
//#endregion
//#region src/execution/DefaultExecutionContextFactory.d.ts
declare class DefaultExecutionContextFactory implements ExecutionContextFactory {
  private readonly binaryStorage;
  private readonly telemetryFactory;
  private readonly costTrackingFactory;
  private readonly currentDate;
  private readonly collections?;
  private readonly nodeResolver?;
  private readonly telemetryDecoratorFactory;
  constructor(binaryStorage?: BinaryStorage, telemetryFactory?: ExecutionTelemetryFactory, costTrackingFactory?: CostTrackingTelemetryFactory, currentDate?: () => Date, collections?: CollectionsContext | undefined, nodeResolver?: NodeResolver | undefined);
  create(args: {
    runId: RunId;
    workflowId: WorkflowId;
    parent?: ParentExecutionRef;
    policySnapshot?: PersistedRunPolicySnapshot;
    subworkflowDepth: number;
    engineMaxNodeActivations: number;
    engineMaxSubworkflowDepth: number;
    data: RunDataSnapshot;
    nodeState?: NodeExecutionStatePublisher;
    telemetry?: ExecutionContext["telemetry"];
    getCredential<TSession = unknown>(slotKey: string): Promise<TSession>;
    testContext?: RunTestContext;
  }): ExecutionContext;
}
//#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/InProcessRetryRunner.d.ts
declare class InProcessRetryRunner {
  private readonly sleeper;
  constructor(sleeper: AsyncSleeper);
  run<T>(policy: RetryPolicySpec | undefined, work: () => Promise<T>, shouldRetry?: (error: unknown) => boolean, warn?: (message: string) => void): Promise<T>;
  private static delayAfterFailureMs;
  private static normalizePolicy;
  private static clampMaxAttempts;
  private static assertPositiveInt;
  private static assertNonNegativeFinite;
  private static assertMultiplier;
}
//#endregion
//#region src/execution/ItemExprResolver.d.ts
declare class ItemExprResolver {
  resolveConfigForItem<TConfig$1 extends RunnableNodeConfig<any, any>>(ctx: NodeExecutionContext<TConfig$1>, item: Item, itemIndex: number, items: ReadonlyArray<Item>): Promise<NodeExecutionContext<TConfig$1>>;
}
//#endregion
//#region src/execution/RunnableOutputBehaviorResolver.d.ts
type RunnableOutputBehavior = Readonly<{
  keepBinaries: boolean;
  mergeJson: boolean;
}>;
declare class RunnableOutputBehaviorResolver {
  resolve(config: RunnableNodeConfig): RunnableOutputBehavior;
  private isKeepBinariesEnabled;
  private isMergeJsonEnabled;
}
//#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/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/runStorage/InMemoryBinaryStorageRegistry.d.ts
declare class InMemoryBinaryStorage implements BinaryStorage {
  readonly driverName = "memory";
  private readonly values;
  write(args: {
    storageKey: string;
    body: BinaryBody;
  }): 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>>;
}
//#endregion
//#region src/runStorage/InMemoryRunDataFactory.d.ts
declare class InMemoryRunDataFactory implements RunDataFactory {
  create(initial?: Record<NodeId, NodeOutputs>): MutableRunData;
}
//#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/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
//#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
export { DefaultExecutionContextFactory as $, HitlWorkspaceIdToken as $t, PollingRunCycleResult as A, CollectionFieldDefinition as At, LocalOnlyScheduler as B, ControlPlaneInboxChannelToken as Bt, OAuthFlowStartArgs as C, DefinePollingTriggerTestItemsContext as Ct, WorkflowEdgePortError as D, DefinedCollectionRegistry as Dt, WorkflowEdgePortValidator as E, definePollingTrigger as Et, EngineFactory as F, defineCollection as Ft, StaticCostCatalog as G, InboxDelivery as Gt, DefaultDrivingScheduler as H, InboxChannelResolverSeam as Ht, RunSummaryMapper as I, callableTool as It, NodeOutputNormalizer as J, LocalInboxChannelToken as Jt, NodeInstanceFactory as K, InboxOnDecisionArgs as Kt, InMemoryWorkflowExecutionRepository as L, DefineCredentialOptions as Lt, PollingTriggerStartArgs as M, DefineCollectionOptions as Mt, WorkflowRepositoryWebhookTriggerMatcher as N, DefinedCollection as Nt, WorkflowEdgePortValidationResult as O, CollectionColumnBuilder as Ot, EngineCompositionDeps as P, c as Pt, CatalogBackedCostTrackingTelemetryFactory as Q, HitlTimeoutJobSchedulerToken as Qt, InMemoryRunDataFactory as R, defineCredential as Rt, OAuthFlowExecutor as S, DefinePollingTriggerPollResult as St, OAuthMaterial as T, DefinedPollingTriggerConfig as Tt, InlineDrivingScheduler as U, InboxChannelResolverToken as Ut, HintOnlyOffloadPolicy as V, InboxChannel as Vt, ConfigDrivenOffloadPolicy as W, InboxDeliverArgs as Wt, ItemExprResolver as X, HitlResumeTokenSignerToken as Xt, RunnableOutputBehaviorResolver as Y, HitlResumeTokenSignerSeam as Yt, InProcessRetryRunner as Z, HitlTimeoutJobSchedulerSeam as Zt, CredentialMaterialProvider as _, InMemoryRunEventBus as _t, TestSuiteRunResult as a, SystemClock as an, chatModel as at, MaterialBundle as b, DefinePollingTriggerOptions as bt, IWorkspaceFileRegistrar as c, AbortControllerFactory as cn, tool as ct, WorkspaceFileNotFoundError as d, PersistedRuntimeTypeMetadataStore as dt, HumanTaskRecord as en, DefaultAsyncSleeper as et, WorkspaceFileRegistrarToken as f, InjectableRuntimeDecoratorComposer as ft, CallerContext as g, EventPublishingWorkflowExecutionRepository as gt, ManagedCredentialMaterialWriteError as h, PersistedRuntimeTypeMetadata as ht, TestSuiteOrchestratorEngine as i, Clock as in, UnavailableBinaryStorage as it, PollingTriggerRuntime as j, CollectionIndexDefinition as jt, PollingRunCycleArgs as k, CollectionDefinition as kt, IWorkspaceFileStorage as l, StackTraceCallSitePathResolver as lt, ManagedMaterialFetchError as m, PersistedRuntimeTypeKind as mt, TestSuiteCaseOutcome as n, HumanTaskStore as nn, ChildExecutionScopeFactory as nt, TestSuiteRunIdFactory as o, NodeEventPublisher as on, getPersistedRuntimeTypeMetadata as ot, WorkspaceFileStorageToken as p, PersistedRuntimeTypeDecoratorOptions as pt, NodeExecutor as q, InboxOnTimeoutArgs as qt, TestSuiteOrchestrator as r, HumanTaskStoreToken as rn, DefaultExecutionBinaryService as rt, MissingRuntimeParityGuard as s, CredentialResolverFactory as sn, node as st, RunTestSuiteArgs as t, HumanTaskStatus as tn, AsyncSleeper as tt, WorkspaceFileMetadata as u, PersistedRuntimeTypeNameResolver as ut, CredentialMaterialRef as v, ConnectionInvocationEventPublisher as vt, OAuthFlowStartResult as w, DefinedPollingTrigger as wt, OAuthFlowCallbackArgs as x, DefinePollingTriggerPollContext as xt, IllegalMaterialSourceError as y, DefinePollingTriggerExecuteContext as yt, InMemoryBinaryStorage as z, DefinedNodeRegistry as zt };
//# sourceMappingURL=index-mnLS0iQl.d.ts.map