import { Er as TriggerSetupStateRepository, Et as Items, Gn as ExecutionContextFactory, H as WorkflowExecutionRepository, Jt as ParentExecutionRef, N as RunResult, Qi as NodeId, U as Container, Ut as NodeOffloadPolicy, Wt as NodeOutputs, Y as TypeToken, Zt as RunDataFactory, _r as RunnableNodeExecuteArgs, ar as NodeExecutionContext, cn as WorkflowDefinition, cr as NodeExecutionScheduler, ft as RunEventBus, gr as RunnableNode, in as TriggerNodeConfig, jr as WorkflowRunnerService, lt as EngineExecutionLimitsPolicy, or as NodeExecutionRequest, ta as WorkflowId, tn as RunnableNodeConfig, wr as TriggerSetupContext, wt as Item, xr as TriggerNode, zi as CredentialSessionService } from "./agentMcpTypes-BHX4RQCC.cjs";
import { n as InMemoryLiveWorkflowRepository, r as Engine, t as RunIntentService } from "./RunIntentService-DKxuHTUz.cjs";
import { a as WorkflowSnapshotCodec, i as EngineWorkflowRunnerService, t as EngineRuntimeRegistrationOptions } from "./EngineRuntimeRegistration.types-BiNasx3G.cjs";
import { ZodType } from "zod";
import { DependencyContainer, InjectionToken } from "tsyringe";

//#region src/testing/RejectingCredentialSessionService.d.ts
declare class RejectingCredentialSessionService implements CredentialSessionService {
  getSession<TSession = unknown>(args: Readonly<{
    workflowId: string;
    nodeId: string;
    slotKey: string;
  }>): Promise<TSession>;
}
//#endregion
//#region src/testing/ItemHarnessNodeConfig.d.ts
declare class ItemHarnessNodeConfig<TIn = unknown, TOut = unknown> implements RunnableNodeConfig<TIn, TOut> {
  readonly name: string;
  readonly inputSchema: ZodType<TIn>;
  readonly runOne: (args: {
    input: TIn;
    item: Item<TIn>;
    itemIndex: number;
    items: Items<TIn>;
    ctx: NodeExecutionContext<ItemHarnessNodeConfig<TIn, TOut>>;
  }) => TOut | Promise<TOut>;
  readonly opts: Readonly<{
    id?: string;
  }>;
  readonly kind: "node";
  readonly type: TypeToken<unknown>;
  constructor(name: string, inputSchema: ZodType<TIn>, runOne: (args: {
    input: TIn;
    item: Item<TIn>;
    itemIndex: number;
    items: Items<TIn>;
    ctx: NodeExecutionContext<ItemHarnessNodeConfig<TIn, TOut>>;
  }) => TOut | Promise<TOut>, opts?: Readonly<{
    id?: string;
  }>);
  get id(): string | undefined;
}
//#endregion
//#region src/testing/ItemHarnessNode.d.ts
declare class ItemHarnessNode implements RunnableNode<ItemHarnessNodeConfig<any, any>> {
  readonly kind: "node";
  readonly outputPorts: readonly ["main"];
  execute(args: RunnableNodeExecuteArgs<ItemHarnessNodeConfig<any, any>>): Promise<unknown>;
}
//#endregion
//#region src/testing/CapturingScheduler.d.ts
declare class CapturingScheduler implements NodeExecutionScheduler {
  lastRequest: NodeExecutionRequest | undefined;
  requests: NodeExecutionRequest[];
  enqueue(request: NodeExecutionRequest): Promise<{
    receiptId: string;
  }>;
}
//#endregion
//#region src/testing/PrefixedSequentialIdGenerator.d.ts
declare class PrefixedSequentialIdGenerator {
  private readonly prefix;
  private n;
  constructor(prefix: string);
  next(): string;
  asFn(): () => string;
}
//#endregion
//#region src/testing/RegistrarEngineTestKit.types.d.ts
type EngineTestKitOptions = Partial<{
  container: Container;
  providers: Map<InjectionToken<unknown>, unknown>;
  credentialSessions: CredentialSessionService;
  runStore: WorkflowExecutionRepository;
  scheduler: NodeExecutionScheduler;
  offloadPolicy: NodeOffloadPolicy;
  runDataFactory: RunDataFactory;
  executionContextFactory: ExecutionContextFactory;
  eventBus: RunEventBus;
  triggerSetupStateRepository: TriggerSetupStateRepository;
  webhookBasePath: string;
  makeRunId: () => string;
  makeActivationId: () => string;
  workflowRunner: EngineWorkflowRunnerService;
  executionLimitsPolicy: EngineExecutionLimitsPolicy;
}>;
type RegistrarEngineTestKitOptions = EngineTestKitOptions & {
  registrarOptions?: EngineRuntimeRegistrationOptions;
};
interface RegistrarEngineTestKitHandle {
  readonly engine: Engine;
  readonly runIntent: RunIntentService;
  readonly liveWorkflowRepository: InMemoryLiveWorkflowRepository;
  readonly runStore: WorkflowExecutionRepository;
  readonly triggerSetupStateRepository: TriggerSetupStateRepository;
  readonly scheduler: CapturingScheduler | NodeExecutionScheduler;
  readonly offloadPolicy: NodeOffloadPolicy;
  readonly workflowRunner: EngineWorkflowRunnerService;
  readonly dependencyContainer: DependencyContainer;
  start(workflows: ReadonlyArray<WorkflowDefinition>): Promise<void>;
  runToCompletion(args: {
    wf: WorkflowDefinition;
    startAt: string;
    items: Items;
    parent?: ParentExecutionRef;
  }): Promise<RunResult>;
  runIntentStartToCompletion(args: {
    wf: WorkflowDefinition;
    startAt: string;
    items: Items;
    parent?: ParentExecutionRef;
  }): Promise<RunResult>;
  readonly makeRunId: () => string;
  readonly makeActivationId: () => string;
}
//#endregion
//#region src/testing/RegistrarEngineTestKitFactory.d.ts
declare class RegistrarEngineTestKitFactory {
  static create(options?: RegistrarEngineTestKitOptions): RegistrarEngineTestKitHandle;
}
//#endregion
//#region src/testing/SubWorkflowRunnerTestNode.d.ts
declare class SubWorkflowRunnerConfig<TInputJson = unknown, TOutputJson = unknown> implements RunnableNodeConfig<TInputJson, TOutputJson> {
  readonly name: string;
  readonly args: Readonly<{
    workflowId: WorkflowId;
    startAt?: NodeId;
    id?: string;
    execution?: Readonly<{
      hint?: "local" | "worker";
      queue?: string;
    }>;
  }>;
  readonly kind: "node";
  readonly type: TypeToken<unknown>;
  readonly workflowId: WorkflowId;
  readonly startAt: NodeId | undefined;
  constructor(name: string, args: Readonly<{
    workflowId: WorkflowId;
    startAt?: NodeId;
    id?: string;
    execution?: Readonly<{
      hint?: "local" | "worker";
      queue?: string;
    }>;
  }>);
  get id(): string | undefined;
  get execution(): Readonly<{
    hint?: "local" | "worker";
    queue?: string;
  }> | undefined;
}
declare class SubWorkflowRunnerNode implements RunnableNode<SubWorkflowRunnerConfig<any, any>> {
  private readonly workflows;
  readonly kind: "node";
  readonly outputPorts: readonly ["main"];
  constructor(workflows: WorkflowRunnerService);
  execute(args: RunnableNodeExecuteArgs<SubWorkflowRunnerConfig<any, any>>): Promise<unknown>;
}
//#endregion
//#region src/testing/WorkflowTestHarnessManualTrigger.d.ts
declare class WorkflowTestHarnessManualTriggerConfig implements TriggerNodeConfig<unknown> {
  readonly name: string;
  readonly id?: string | undefined;
  readonly kind: "trigger";
  readonly type: TypeToken<unknown>;
  constructor(name: string, id?: string | undefined);
}
declare class WorkflowTestHarnessManualTriggerNode implements TriggerNode<WorkflowTestHarnessManualTriggerConfig> {
  readonly kind: "trigger";
  readonly outputPorts: readonly ["main"];
  setup(_ctx: TriggerSetupContext<WorkflowTestHarnessManualTriggerConfig>): Promise<undefined>;
  execute(items: Items, _ctx: NodeExecutionContext<WorkflowTestHarnessManualTriggerConfig>): Promise<NodeOutputs>;
}
//#endregion
//#region src/testing/WorkflowTestKit.types.d.ts
type DefinedNodeRegistrationContext = {
  registerNode<TValue>(token: TypeToken<TValue>, implementation?: TypeToken<TValue>): void;
};
type DefinedNodeRegistration = {
  register(context: DefinedNodeRegistrationContext): void;
};
//#endregion
//#region src/testing/WorkflowTestKitBuilder.d.ts
type WorkflowTestKitOptions = EngineTestKitOptions;
declare class WorkflowTestKit {
  private readonly handle;
  private readonly runNodeWorkflowFactory;
  private readonly nodeRegistrationContextFactory;
  constructor(options?: WorkflowTestKitOptions);
  get dependencyContainer(): DependencyContainer;
  get engine(): RegistrarEngineTestKitHandle["engine"];
  get workflowRunner(): RegistrarEngineTestKitHandle["workflowRunner"];
  get liveWorkflowRepository(): RegistrarEngineTestKitHandle["liveWorkflowRepository"];
  get runStore(): RegistrarEngineTestKitHandle["runStore"];
  registerDefinedNodes(definitions: ReadonlyArray<DefinedNodeRegistration>): void;
  run(args: {
    workflow: WorkflowDefinition;
    items: Items;
    startAt?: NodeId;
  }): Promise<RunResult>;
  runNode(args: {
    node: RunnableNodeConfig;
    items: Items;
    workflowId?: WorkflowId;
    workflowName?: string;
  }): Promise<RunResult>;
}
//#endregion
export { CapturingScheduler, type DefinedNodeRegistration, type DefinedNodeRegistrationContext, type EngineTestKitOptions, InMemoryLiveWorkflowRepository, ItemHarnessNode, ItemHarnessNodeConfig, WorkflowSnapshotCodec as PersistedWorkflowSnapshotFactory, PrefixedSequentialIdGenerator, RegistrarEngineTestKitFactory, type RegistrarEngineTestKitHandle, type RegistrarEngineTestKitOptions, RejectingCredentialSessionService, SubWorkflowRunnerConfig, SubWorkflowRunnerNode, WorkflowTestHarnessManualTriggerConfig, WorkflowTestHarnessManualTriggerNode, WorkflowTestKit, type WorkflowTestKitOptions };
//# sourceMappingURL=testing.d.cts.map