import zod from "zod";
import type { GenericRecord } from "@webiny/api/types";
import type { ITask } from "../../../features/task/TaskService/index.js";
import { TaskController } from "../../../features/task/TaskController/index.js";
export type ITaskInput = GenericRecord;
export interface IResponseError {
    message: string;
    code?: string | null;
    data?: GenericRecord | null;
    stack?: string;
}
export interface ITaskOutput {
    error?: IResponseError;
    [key: string]: any;
}
/**
 * Task run params - ONLY the input data
 * All runtime dependencies come from TaskController (injected separately)
 */
export interface ITaskRunParams<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> {
    input: I;
    controller: TaskController.Interface<I, O>;
}
/**
 * Data for creating a new task
 */
export interface ITaskCreateData<I = ITaskInput> {
    definitionId: string;
    name: string;
    input: I;
    parentId?: string;
}
/**
 * Parameters for onBeforeTrigger lifecycle hook
 */
export interface ITaskBeforeTriggerParams<I = ITaskInput> {
    data: ITaskCreateData<I>;
}
/**
 * Task result status enum
 */
export declare enum TaskResultStatus {
    DONE = "done",
    CONTINUE = "continue",
    ERROR = "error",
    ABORTED = "aborted"
}
/**
 * Specific result types
 */
export interface ITaskResultDone<O extends ITaskOutput = ITaskOutput> {
    status: TaskResultStatus.DONE;
    message?: string;
    output?: O;
}
export interface ITaskResultContinue<I = ITaskInput> {
    status: TaskResultStatus.CONTINUE;
    input: I;
    wait?: number;
}
export interface ITaskResultError {
    status: TaskResultStatus.ERROR;
    error: IResponseError;
}
export interface ITaskResultAborted {
    status: TaskResultStatus.ABORTED;
}
export type ITaskResult<I = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskResultDone<O> | ITaskResultContinue<I> | ITaskResultError | ITaskResultAborted;
export type ISelfCleanupEvent = "onSuccess" | "onError" | "onAbort";
export type ISelfCleanup = "always" | "never" | ISelfCleanupEvent | ISelfCleanupEvent[];
export type ITaskLifecycleHook<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = {
    task: ITask<I, O>;
};
/**
 * Core TaskDefinition - minimal interface
 */
export interface ITaskDefinition<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> {
    id: string;
    title: string;
    description?: string;
    maxIterations?: number;
    databaseLogs?: boolean;
    isPrivate?: boolean;
    selfCleanup?: ISelfCleanup;
    /**
     * Core run method - receives ONLY input params
     * All runtime dependencies (logging, state management, etc.) come from TaskController
     */
    run(params: ITaskRunParams<I, O>): Promise<ITaskResult<I, O>>;
    /**
     * Optional lifecycle hooks - receive task data, no context.
     */
    onBeforeTrigger?(params: ITaskBeforeTriggerParams<I>): Promise<void>;
    onDone?(params: ITaskLifecycleHook<I, O>): Promise<void>;
    onError?(params: ITaskLifecycleHook<I, O>): Promise<void>;
    onAbort?(params: ITaskLifecycleHook<I, O>): Promise<void>;
    onMaxIterations?(params: ITaskLifecycleHook<I, O>): Promise<void>;
    /**
     * Create a validation schema for the task input.
     * This will be used to validate the input before the task is triggered.
     */
    createInputValidation?(params: ITaskCreateInputValidationParams): GenericRecord<keyof I, zod.Schema> | zod.Schema;
}
export interface ITaskCreateInputValidationParams {
    validator: typeof zod;
}
/** Define a long-running background task with lifecycle hooks. */
export declare const TaskDefinition: import("@webiny/di").Abstraction<ITaskDefinition<ITaskInput, ITaskOutput>>;
/**
 * IRunnableTaskDefinition represents a TaskDefinition after decoration/processing.
 * All optional runtime properties are guaranteed to have values (with defaults applied).
 * Used internally by the task runner to ensure consistent behavior.
 */
export interface IRunnableTaskDefinition<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> extends ITaskDefinition<I, O> {
    isPrivate: boolean;
    databaseLogs: boolean;
    maxIterations: number;
}
export declare namespace TaskDefinition {
    type Interface<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskDefinition<I, O>;
    type TaskInput = ITaskInput;
    type TaskOutput = ITaskOutput;
    type Runnable<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = IRunnableTaskDefinition<I, O>;
    type RunParams<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskRunParams<I, O>;
    type Result<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskResult<I, O>;
    type Task<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITask<I, O>;
    type ResultDone<O extends ITaskOutput = ITaskOutput> = ITaskResultDone<O>;
    type ResultContinue<I = ITaskInput> = ITaskResultContinue<I>;
    type ResultError = ITaskResultError;
    type ResultAborted = ITaskResultAborted;
    type CreateInputValidationParams = ITaskCreateInputValidationParams;
    type TaskCreateData<I = ITaskInput> = ITaskCreateData<I>;
    type BeforeTriggerParams<I = ITaskInput> = ITaskBeforeTriggerParams<I>;
    type LifecycleHookParams<I extends ITaskInput = ITaskInput, O extends ITaskOutput = ITaskOutput> = ITaskLifecycleHook<I, O>;
    type SelfCleanupEvent = ISelfCleanupEvent;
    type SelfCleanup = ISelfCleanup;
}