import type { WorkpoolOptions, WorkpoolRetryOptions } from "@convex-dev/workpool";
import { type FunctionArgs, type FunctionReference, type FunctionVisibility, type GenericDataModel, type GenericMutationCtx, type GenericQueryCtx, type PaginationOptions, type PaginationResult, type RegisteredMutation, type ReturnValueForOptionalValidator } from "convex/server";
import type { Infer, ObjectType, PropertyValidators, Validator } from "convex/values";
import type { Step } from "../component/schema.js";
import type { EventId, OnCompleteArgs, PublicWorkflow, WorkflowId, WorkflowStep } from "../types.js";
import type { IdsToStrings, WorkflowComponent } from "./types.js";
import type { WorkflowCtx } from "./workflowContext.js";
export { vEventId, vWorkflowId, vWorkflowStep, type EventId, type WorkflowId, type WorkflowStep, } from "../types.js";
export type { RunOptions, WorkflowCtx } from "./workflowContext.js";
export type CallbackOptions = {
    /**
     * A mutation to run after the function succeeds, fails, or is canceled.
     * The context type is for your use, feel free to provide a validator for it.
     * e.g.
     * ```ts
     * export const completion = internalMutation({
     *  args: {
     *    workId: workIdValidator,
     *    context: v.any(),
     *    result: resultValidator,
     *  },
     *  handler: async (ctx, args) => {
     *    console.log(args.result, "Got Context back -> ", args.context, Date.now() - args.context);
     *  },
     * });
     * ```
     */
    onComplete?: FunctionReference<"mutation", FunctionVisibility, OnCompleteArgs> | null;
    /**
     * A context object to pass to the `onComplete` mutation.
     * Useful for passing data from the enqueue site to the onComplete site.
     */
    context?: unknown;
};
export type WorkflowDefinition<ArgsValidator extends PropertyValidators, ReturnsValidator extends Validator<any, "required", any> | void = any> = {
    args?: ArgsValidator;
    handler: (step: WorkflowCtx, args: ObjectType<ArgsValidator>) => Promise<ReturnValueForOptionalValidator<ReturnsValidator>>;
    returns?: ReturnsValidator;
    workpoolOptions?: WorkpoolRetryOptions;
};
export type WorkflowStatus = {
    type: "inProgress";
    running: IdsToStrings<Step>[];
} | {
    type: "completed";
    result: unknown;
} | {
    type: "canceled";
} | {
    type: "failed";
    error: string;
};
export declare class WorkflowManager {
    component: WorkflowComponent;
    options?: {
        workpoolOptions: WorkpoolOptions;
    } | undefined;
    constructor(component: WorkflowComponent, options?: {
        workpoolOptions: WorkpoolOptions;
    } | undefined);
    /**
     * Define a new workflow.
     *
     * @param workflow - The workflow definition.
     * @returns The workflow mutation.
     */
    define<ArgsValidator extends PropertyValidators, ReturnsValidator extends Validator<unknown, "required", string> | void>(workflow: WorkflowDefinition<ArgsValidator, ReturnsValidator>): RegisteredMutation<"internal", {
        fn: "You should not call this directly, call workflow.start instead";
        args: ObjectType<ArgsValidator>;
    }, ReturnsValidator extends Validator<unknown, "required", string> ? Infer<ReturnsValidator> : void>;
    /**
     * Kick off a defined workflow.
     *
     * @param ctx - The Convex context.
     * @param workflow - The workflow to start (e.g. `internal.index.exampleWorkflow`).
     * @param args - The workflow arguments.
     * @returns The workflow ID.
     */
    start<F extends FunctionReference<"mutation", "internal">>(ctx: RunMutationCtx, workflow: F, args: FunctionArgs<F>["args"], options?: CallbackOptions & {
        /**
         * By default, during creation the workflow will be initiated immediately.
         * The benefit is that you catch errors earlier (e.g. passing a bad
         * workflow reference or catch arg validation).
         *
         * With `startAsync` set to true, the workflow will be created but will
         * start asynchronously via the internal workpool.
         * You can use this to queue up a lot of work,
         * or make `start` return faster (you still get a workflowId back).
         * @default false
         */
        startAsync?: boolean;
        /** @deprecated Use `startAsync` instead. */
        validateAsync?: boolean;
    }): Promise<WorkflowId>;
    /**
     * Get a workflow's status.
     *
     * @param ctx - The Convex context.
     * @param workflowId - The workflow ID.
     * @returns The workflow status.
     */
    status(ctx: RunQueryCtx, workflowId: WorkflowId): Promise<WorkflowStatus>;
    /**
     * Restart a previously-failed workflow.
     *
     * By default it will retry the handler using the existing history of steps.
     * To restart from the beginning, pass `{from: 0}`.
     * To restart from a named step or event: `{from: "myName"}`.
     * To restart from a function call: `{from: internal.foo.bar}`.
     *
     * If the function or name were called multiple times, it will restart from
     * the last invocation.
     *
     * @param ctx - The Convex context.
     * @param workflowId - The workflow ID.
     * @param options - Options for the retry.
     * @param options.from - The step to retry from. Can be a step number,
     *   a step name, or the function / workflow `internal.foo.bar`.
     *   Steps from this point onwards will be deleted before restarting.
     *   If not provided, the handler will be re-executed using the existing
     *   history of steps.
     * @param options.startAsync - If true, the workflow will be enqueued
     *   via the workpool instead of running immediately.
     */
    restart(ctx: RunMutationCtx, workflowId: WorkflowId, options?: {
        from?: number | string | FunctionReference<any, any>;
        startAsync?: boolean;
    }): Promise<void>;
    /**
     * Cancel a running workflow.
     *
     * @param ctx - The Convex context.
     * @param workflowId - The workflow ID.
     */
    cancel(ctx: RunMutationCtx, workflowId: WorkflowId): Promise<void>;
    /**
     * List workflows, including their name, args, return value etc.
     *
     * @param ctx - The Convex context from a query, mutation, or action.
     * @param opts - How many workflows to fetch and in what order.
     *   e.g. `{ order: "desc", paginationOpts: { cursor: null, numItems: 10 } }`
     *   will get the last 10 workflows in descending order.
     *   Defaults to 100 workflows in ascending order.
     * @returns The pagination result with per-workflow data.
     */
    list(ctx: RunQueryCtx, opts?: {
        order?: "asc" | "desc";
        paginationOpts?: PaginationOptions;
    }): Promise<PaginationResult<PublicWorkflow>>;
    /**
     * List workflows matching a specific name, including their args, return value etc.
     *
     * @param ctx - The Convex context from a query, mutation, or action.
     * @param name - The workflow name to filter by.
     * @param opts - How many workflows to fetch and in what order.
     *   e.g. `{ order: "desc", paginationOpts: { cursor: null, numItems: 10 } }`
     *   will get the last 10 workflows in descending order.
     *   Defaults to 100 workflows in ascending order.
     * @returns The pagination result with per-workflow data.
     */
    listByName(ctx: RunQueryCtx, name: string, opts?: {
        order?: "asc" | "desc";
        paginationOpts?: PaginationOptions;
    }): Promise<PaginationResult<PublicWorkflow>>;
    /**
     * List the steps in a workflow, including their name, args, return value etc.
     *
     * @param ctx - The Convex context from a query, mutation, or action.
     * @param workflowId - The workflow ID.
     * @param opts - How many steps to fetch and in what order.
     *   e.g. `{ order: "desc", paginationOpts: { cursor: null, numItems: 10 } }`
     *   will get the last 10 steps in descending order.
     *   Defaults to 100 steps in ascending order.
     * @returns The pagination result with per-step data.
     */
    listSteps(ctx: RunQueryCtx, workflowId: WorkflowId, opts?: {
        order?: "asc" | "desc";
        paginationOpts?: PaginationOptions;
    }): Promise<PaginationResult<WorkflowStep>>;
    /**
     * Clean up a completed workflow's storage.
     *
     * @param ctx - The Convex context.
     * @param workflowId - The workflow ID.
     * @returns - Whether the workflow's state was cleaned up.
     */
    cleanup(ctx: RunMutationCtx, workflowId: WorkflowId): Promise<boolean>;
    /**
     * Send an event to a workflow.
     *
     * @param ctx - From a mutation, action or workflow step.
     * @param args - Either send an event by its ID, or by name and workflow ID.
     *   If you have a validator, you must provide a value.
     *   If you provide an error string, awaiting the event will throw an error.
     */
    sendEvent<T = null, Name extends string = string>(ctx: RunMutationCtx, args: ({
        workflowId: WorkflowId;
        name: Name;
        id?: EventId<Name>;
    } | {
        workflowId?: undefined;
        name?: Name;
        id: EventId<Name>;
    }) & ({
        validator?: undefined;
        value?: T;
    } | {
        validator: Validator<T, any, any>;
        value: T;
    } | {
        error: string;
        value?: undefined;
    })): Promise<EventId<Name>>;
    /**
     * Create an event ahead of time, enabling awaiting a specific event by ID.
     * @param ctx - From an action, mutation or workflow step.
     * @param args - The name of the event and what workflow it belongs to.
     * @returns The event ID, which can be used to send the event or await it.
     */
    createEvent<Name extends string>(ctx: RunMutationCtx, args: {
        name: Name;
        workflowId: WorkflowId;
    }): Promise<EventId<Name>>;
}
/**
 * Define an event specification: a name and a validator.
 * This helps share definitions between workflow.sendEvent and ctx.awaitEvent.
 * e.g.
 * ```ts
 * const approvalEvent = defineEvent({
 *   name: "approval",
 *   validator: v.object({ approved: v.boolean() }),
 * });
 * ```
 * Then you can await it in a workflow:
 * ```ts
 * const result = await ctx.awaitEvent(approvalEvent);
 * ```
 * And send from somewhere else:
 * ```ts
 * await workflow.sendEvent(ctx, {
 *   ...approvalEvent,
 *   workflowId,
 *   value: { approved: true },
 * });
 * ```
 */
export declare function defineEvent<Name extends string, V extends Validator<unknown, "required", string>>(spec: {
    name: Name;
    validator: V;
}): {
    name: Name;
    validator: V;
};
type RunQueryCtx = {
    runQuery: GenericQueryCtx<GenericDataModel>["runQuery"];
};
type RunMutationCtx = {
    runMutation: GenericMutationCtx<GenericDataModel>["runMutation"];
};
//# sourceMappingURL=index.d.ts.map