import { $t as RunId, An as RetryPolicySpec, Fn as BinaryStorageReadResult, Gn as ExecutionContextFactory, In as BinaryStorageStatResult, Jt as ParentExecutionRef, Kn as HumanTaskActor, Mt as MutableRunData, Nn as BinaryBody, Nt as NodeActivationId, Pn as BinaryStorage, Qi as NodeId, Qt as RunDataSnapshot, R as RunTestContext, Rn as BinaryStorageWriteResult, Un as ExecutionBinaryService, Wn as ExecutionContext, Wr as ExecutionTelemetryFactory, Wt as NodeOutputs, Y as TypeToken, Yn as HumanTaskSubject, Yt as PersistedRunPolicySnapshot, Zt as RunDataFactory, ar as NodeExecutionContext, bt as BinaryAttachment, dr as NodeResolver, ir as NodeBinaryAttachmentService, jt as JsonValue, lr as NodeExecutionStatePublisher, mi as CostTrackingTelemetryFactory, ta as WorkflowId, tn as RunnableNodeConfig, vi as CollectionsContext, wt as Item, zi as CredentialSessionService } from "./agentMcpTypes-BHX4RQCC.cjs";

//#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/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/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/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/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 extends RunnableNodeConfig<any, any>>(ctx: NodeExecutionContext<TConfig>, item: Item, itemIndex: number, items: ReadonlyArray<Item>): Promise<NodeExecutionContext<TConfig>>;
}
//#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/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
export { HumanTaskRecord as _, ItemExprResolver as a, HumanTaskStoreToken as b, DefaultAsyncSleeper as c, UnavailableBinaryStorage as d, HitlResumeTokenSignerSeam as f, HitlWorkspaceIdToken as g, HitlTimeoutJobSchedulerToken as h, RunnableOutputBehaviorResolver as i, AsyncSleeper as l, HitlTimeoutJobSchedulerSeam as m, InMemoryBinaryStorage as n, InProcessRetryRunner as o, HitlResumeTokenSignerToken as p, RunnableOutputBehavior as r, DefaultExecutionContextFactory as s, InMemoryRunDataFactory as t, DefaultExecutionBinaryService as u, HumanTaskStatus as v, CredentialResolverFactory as x, HumanTaskStore as y };
//# sourceMappingURL=InMemoryRunDataFactory-D2U9azmZ.d.cts.map