import { TailorEnv } from "../../runtime/types.mjs";
import { ExecJobFunctionOptions, StartWorkflowOptions } from "../../runtime/workflow.mjs";
import { WorkflowJob } from "../../configure/services/workflow/job.mjs";
import { Workflow } from "../../configure/services/workflow/workflow.mjs";
import { ParameterizedWaitPointInstance, WaitPointInstance } from "../../configure/services/workflow/wait-point.mjs";
import { Mock } from "vitest";
//#region src/vitest/mocks/workflow.d.ts
type JobHandler = (jobName: string, args: unknown, options?: ExecJobFunctionOptions) => unknown;
type StartHandlerFn = (workflowName: string, args: unknown, options?: StartWorkflowOptions) => string;
type ResumeHandlerFn = (executionId: string) => string;
type WaitHandlerFn = (key: string, payload: unknown) => unknown;
type ResolveHandler = (executionId: string, key: string, callback: (payload: unknown) => unknown) => unknown | Promise<unknown>;
type SetWaitHandler = {
  (handler: WaitHandlerFn): void;
  (handler: unknown): void;
};
interface StartedJob {
  jobName: string;
  args: unknown;
  options?: ExecJobFunctionOptions;
}
type WaitPayload<Payload> = [Payload] extends [undefined] ? undefined : Payload;
/**
 * Acquire a disposable mock for workflow operations (`tailor.workflow`).
 * Restored on dispose.
 * @returns Disposable workflow mock control object
 * @example
 * ```typescript
 * import { mockWorkflow } from "@tailor-platform/sdk/vitest";
 *
 * test("job start", async () => {
 *   using wf = mockWorkflow();
 *   const job = wf.job(validateOrder);
 *   job.mockResolvedValue({ valid: true });
 *   await runWorkflowUnderTest();
 *   expect(job).toHaveBeenCalled();
 * });
 * ```
 */
export declare function mockWorkflow(): {
  /** The `execJobFunction` `vi.fn`. */
  execJobFunction: Mock<(jobName: string, _args?: unknown, _options?: ExecJobFunctionOptions) => unknown>;
  /** The `startWorkflow` `vi.fn`. */
  startWorkflow: Mock<(_workflowName: string, _args?: unknown, _options?: StartWorkflowOptions) => Promise<string>>;
  /** The `resumeWorkflowExecution` `vi.fn`. */
  resumeWorkflowExecution: Mock<(executionId: string) => Promise<string>>;
  /** The `wait` `vi.fn`. */
  wait: Mock<(_key: string, _payload?: unknown) => unknown>;
  /** The `resolve` `vi.fn`. */
  resolve: Mock<(_executionId: string, _key: string, _callback: (payload: unknown) => unknown) => Promise<void>>;
  /**
   * Get a stable, typed mock for a workflow job's `start` method.
   * The real start behavior is used until an implementation or result is configured.
   * @param definition - Workflow job definition to mock
   * @returns Typed `start` mock for the definition
   */
  job<Name extends string, Input, Output>(definition: WorkflowJob<Name, Input, Output>): Mock<WorkflowJob<Name, Input, Output>["start"]>;
  /**
   * Get a stable, typed mock for a workflow definition's `start` method.
   * The real start behavior is used until an implementation or result is configured.
   * @param definition - Workflow definition to mock
   * @returns Typed `start` mock for the definition
   */
  workflow<Definition extends Workflow>(definition: Definition): Mock<Definition["start"]>;
  /**
   * Get stable, typed mocks for a wait point's `wait` and `resolve` methods.
   * @param definition - Wait point definition to mock
   * @returns Typed wait point mock control object
   */
  waitPoint<Payload, Result>(definition: WaitPointInstance<Payload, Result>): {
    wait: Mock<WaitPointInstance<Payload, Result>["wait"]>;
    resolve: Mock<WaitPointInstance<Payload, Result>["resolve"]>;
    setResolvePayload(payload: WaitPayload<Payload>): void;
  };
  /**
   * Get stable, typed mocks for one param binding of a parameterized wait point.
   * Calls made with other bindings fall through to the platform mock.
   * @param definition - Parameterized wait point definition to mock
   * @param params - Param binding to intercept, as passed to `.with()`
   * @returns Typed wait point mock control object
   */
  waitPointWith<Params extends object, Payload, Result>(definition: ParameterizedWaitPointInstance<Params, Payload, Result>, params: Params): {
    wait: Mock<WaitPointInstance<Payload, Result>["wait"]>;
    resolve: Mock<WaitPointInstance<Payload, Result>["resolve"]>;
    setResolvePayload(payload: WaitPayload<Payload>): void;
  };
  /**
   * Set a fallback job handler. Called when the enqueue queue is empty.
   * @param handler - Function returning a result for a job name, args, and options
   */
  setJobHandler(handler: JobHandler): void;
  /**
   * Enqueue a single result for the next `execJobFunction` call (FIFO;
   * takes priority over `setJobHandler`).
   * @param result - Result to return from the next call
   */
  enqueueResult(result: unknown): void;
  /**
   * Enqueue results for multiple subsequent `execJobFunction` calls (FIFO).
   * @param results - Results to enqueue, one per upcoming call
   */
  enqueueResults(...results: unknown[]): void;
  /**
   * All jobs executed via `execJobFunction`, in order.
   * @returns Started jobs array
   */
  readonly startedJobs: StartedJob[];
  /**
   * Configure what `startWorkflow` returns. Pass a string (same id every
   * call) or `(name, args, options) => string`. Default: a placeholder UUID.
   * @param handler - Static execution ID or a function returning one
   */
  setStartHandler(handler: string | StartHandlerFn): void;
  /**
   * Configure what `resumeWorkflowExecution` returns. Pass a string (same id
   * every call) or `(executionId) => string`. Default: echoes the input executionId.
   * @param handler - Static execution ID or a function returning one
   */
  setResumeHandler(handler: string | ResumeHandlerFn): void;
  /**
   * Configure what `wait` returns. Pass `(key, payload) => unknown` or any
   * other value to return it for every call. Default: `null`.
   * @param handler - Static value or a function returning one
   */
  setWaitHandler: SetWaitHandler;
  /**
   * Set the `env` passed to job bodies invoked via `createWorkflowJob().start()`.
   * Cleared on dispose / reset.
   * @param env - Env passed to job bodies.
   */
  setEnv(env: TailorEnv): void;
  /**
   * Configure how `resolve` runs the user-supplied callback. Default: callback
   * is not invoked (records the call only).
   * @param handler - Function invoked per `resolve` call
   */
  setResolveHandler(handler: ResolveHandler): void;
  /**
   * `wait` calls reshaped as `{ key, payload }` for assertions.
   * @returns Wait call records
   */
  readonly waitCalls: {
    key: string;
    payload: unknown;
  }[];
  /**
   * `resolve` calls reshaped as `{ executionId, key }` for assertions.
   * @returns Resolve call records
   */
  readonly resolveCalls: {
    executionId: string;
    key: string;
  }[];
  /** Clear recorded calls while preserving configured responses. */
  clear(): void;
  /** Reset all workflow responses and recorded calls (keeps the mock installed). */
  reset(): void;
} & Disposable;
//#endregion