import { TaskModel } from "./models/TaskModel";
import { BackoffStrategy, JitterStrategy, TaskStatus, TaskType } from "./constants";
import { TaskBackoffModel } from "./models/index";
import { TaskStepSpecModel } from "./models/TaskStepSpecModel";
import { Model, ModelArg } from "@decaf-ts/decorator-validation";
export declare class TaskBackoffBuilder<NESTED extends boolean = false> extends Model {
    baseMs: number;
    jitter: JitterStrategy;
    maxMs: number;
    strategy: BackoffStrategy;
    constructor(arg?: ModelArg<TaskBackoffBuilder>);
    setBaseMs(value: number): this;
    setJitter(value: JitterStrategy): this;
    setMaxMs(value: number): this;
    setStrategy(value: BackoffStrategy): this;
    build(): NESTED extends false ? TaskBackoffModel : TaskBuilder;
}
export declare class TaskBuilder extends Model {
    protected classification: string;
    protected status: TaskStatus;
    protected atomicity: TaskType;
    protected backoff: TaskBackoffModel;
    protected input?: any;
    protected attempt: number;
    protected maxAttempts: number;
    setClassification(value: string): this;
    setStatus(value: TaskStatus): this;
    setAtomicity(value: TaskType): this;
    setBackoff<V extends TaskBackoffModel>(value?: TaskBackoffModel): V extends TaskBackoffModel ? this : TaskBackoffBuilder<true>;
    setInput(value: any): this;
    setMaxAttempts(value: number): this;
    setAttempt(value: number): this;
    constructor(arg?: ModelArg<TaskBuilder>);
    build(): TaskModel;
}
export declare class CompositeTaskBuilder extends TaskBuilder {
    protected steps?: TaskStepSpecModel[];
    protected stepResults?: TaskStepSpecModel[];
    constructor(arg?: ModelArg<CompositeTaskBuilder>);
    setSteps(value: TaskStepSpecModel[]): this;
    addStep(classification: string, input?: any): this;
}