import { A as RunId, B as RunExecutionOptions, D as NodeOutputs, Dt as WebhookInvocationMatch, Et as HttpMethod, F as CurrentStateExecutionRequest, Ft as NodeId, H as RunResult, I as NodeInputsByPort, It as WorkflowId, K as WebhookRunResult, O as ParentExecutionRef, Ot as WebhookTriggerMatcher, P as WorkflowDefinition, R as PersistedWorkflowTokenRegistryLike, S as Items, W as RunStopCondition, _ as WorkflowRepository, d as NodeActivationContinuation, g as ResumeContext, kt as WebhookTriggerResolution, m as NodeExecutionRequestHandler, p as NodeExecutionRequest, q as WorkflowExecutionRepository, u as LiveWorkflowRepository, v as WorkflowSnapshotResolver, w as NodeActivationId, z as RunCurrentState } from "./ItemsInputNormalizer-C2gLv7d9.js";
import { ZodType } from "zod";

//#region ../core/src/contracts/Clock.d.ts
interface Clock {
  now(): Date;
}
//#endregion
//#region ../core/src/authoring/defineCollection.types.d.ts
type CollectionFieldType = "text" | "int" | "bigint" | "double" | "bool" | "timestamptz" | "jsonb" | "uuid";
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;
}
//#endregion
//#region ../core/src/orchestration/Engine.d.ts
interface EngineTriggerRuntime {
  startTriggers(): Promise<void>;
  stop(): Promise<void>;
  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
  createTriggerTestItems(args: {
    workflow: WorkflowDefinition;
    nodeId: NodeId;
  }): Promise<Items | undefined>;
}
interface EngineRunStartService {
  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
    mutableState?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
  }>): Promise<RunResult>;
  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
}
interface EngineRunContinuationService {
  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>;
  resumeFromStepResult(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    outputs: NodeOutputs;
  }): Promise<RunResult>;
  resumeFromStepError(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    error: Error;
  }): Promise<RunResult>;
  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
    status: "completed" | "failed" | "halted";
  }>>;
  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
  resumeRun(args: {
    runId: RunId;
    taskId: string;
    resumeContext: ResumeContext;
  }): Promise<RunResult>;
}
interface EngineNodeExecutionRequestHandler {
  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
}
interface EngineFacadeDeps {
  liveWorkflowRepository: LiveWorkflowRepository;
  tokenRegistry: PersistedWorkflowTokenRegistryLike;
  webhookTriggerMatcher: WebhookTriggerMatcher;
  workflowSnapshotResolver: WorkflowSnapshotResolver;
  triggerRuntime: EngineTriggerRuntime;
  runStartService: EngineRunStartService;
  runContinuationService: EngineRunContinuationService;
  nodeExecutionRequestHandler: EngineNodeExecutionRequestHandler;
}
declare class Engine implements NodeActivationContinuation, NodeExecutionRequestHandler {
  private readonly deps;
  constructor(deps: EngineFacadeDeps);
  loadWorkflows(workflows: ReadonlyArray<WorkflowDefinition>): void;
  getTokenRegistry(): EngineFacadeDeps["tokenRegistry"];
  resolveWorkflowSnapshot(args: {
    workflowId: WorkflowId;
    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
  }): WorkflowDefinition | undefined;
  startTriggers(): Promise<void>;
  syncWorkflowTriggersForActivation(workflowId: WorkflowId): Promise<void>;
  start(workflows: WorkflowDefinition[]): Promise<void>;
  stop(): Promise<void>;
  resolveWebhookTrigger(args: {
    endpointPath: string;
    method: HttpMethod;
  }): WebhookTriggerResolution;
  createTriggerTestItems(args: {
    workflow: WorkflowDefinition;
    nodeId: NodeId;
  }): Promise<Items | undefined>;
  runWorkflow(wf: WorkflowDefinition, startAt: NodeId, items: Items, parent?: ParentExecutionRef, executionOptions?: RunExecutionOptions, persistedStateOverrides?: Readonly<{
    workflowSnapshot?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["workflowSnapshot"];
    mutableState?: NonNullable<Awaited<ReturnType<WorkflowExecutionRepository["load"]>>>["mutableState"];
  }>): Promise<RunResult>;
  runWorkflowFromState(request: CurrentStateExecutionRequest): Promise<RunResult>;
  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>;
  resumeFromStepResult(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    outputs: NodeOutputs;
  }): Promise<RunResult>;
  resumeFromStepError(args: {
    runId: RunId;
    activationId: NodeActivationId;
    nodeId: NodeId;
    error: Error;
  }): Promise<RunResult>;
  waitForCompletion(runId: RunId): Promise<Extract<RunResult, {
    status: "completed" | "failed" | "halted";
  }>>;
  waitForWebhookResponse(runId: RunId): Promise<WebhookRunResult>;
  resumeRun(args: {
    runId: RunId;
    taskId: string;
    resumeContext: ResumeContext;
  }): Promise<RunResult>;
  handleNodeExecutionRequest(request: NodeExecutionRequest): Promise<void>;
}
//#endregion
//#region ../core/src/runtime/RunIntentService.d.ts
type StartWorkflowIntent = {
  workflow: WorkflowDefinition;
  startAt?: string;
  items: Items;
  synthesizeTriggerItems?: boolean;
  parent?: CurrentStateExecutionRequest["parent"];
  executionOptions?: RunExecutionOptions;
  workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
  mutableState?: CurrentStateExecutionRequest["mutableState"];
  currentState?: RunCurrentState;
  stopCondition?: RunStopCondition;
  reset?: CurrentStateExecutionRequest["reset"];
};
type RerunFromNodeIntent = {
  workflow: WorkflowDefinition;
  nodeId: NodeId;
  currentState: RunCurrentState;
  items?: Items;
  synthesizeTriggerItems?: boolean;
  parent?: CurrentStateExecutionRequest["parent"];
  executionOptions?: RunExecutionOptions;
  workflowSnapshot?: CurrentStateExecutionRequest["workflowSnapshot"];
  mutableState?: CurrentStateExecutionRequest["mutableState"];
};
type MatchedWebhookRunIntent = {
  endpointPath: string;
  method: HttpMethod;
  requestItem: Items[number];
};
type WebhookMatchRunIntent = {
  match: WebhookInvocationMatch;
  requestItem: Items[number];
};
declare class RunIntentService {
  private readonly engine;
  private readonly workflowRepository;
  constructor(engine: Engine, workflowRepository: WorkflowRepository);
  startWorkflow(args: StartWorkflowIntent): Promise<RunResult>;
  rerunFromNode(args: RerunFromNodeIntent): Promise<RunResult>;
  private resolveStartWorkflowItems;
  private resolveRerunItems;
  private resolveStartWorkflowTriggerNodeId;
  private resolveRerunTriggerNodeId;
  private firstTriggerNodeId;
  private isTriggerNode;
  private hasNonEmptyItems;
  resolveWebhookTrigger(args: {
    endpointPath: string;
    method: HttpMethod;
  }): WebhookTriggerResolution;
  runMatchedWebhook(args: MatchedWebhookRunIntent): Promise<WebhookRunResult>;
  runWebhookMatch(args: WebhookMatchRunIntent): Promise<WebhookRunResult>;
  private createWebhookExecutionOptions;
}
//#endregion
//#region ../core/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 ../core/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>;
}
//#endregion
export { CollectionDefinition as a, Engine as i, OAuthFlowExecutor as n, DefinedCollection as o, RunIntentService as r, Clock as s, CredentialMaterialProvider as t };
//# sourceMappingURL=index-Cy08dvyb.d.ts.map