import { StepBody, InlineStepBody } from "../abstractions";
import { WorkflowStep, StepExecutionContext, ExecutionResult } from "../models";
import { WaitFor, Foreach, While, If, Delay, Schedule, Sequence } from "../primitives";
import { WorkflowBuilder } from "./workflow-builder";
import { ReturnStepBuilder } from "./return-step-builder";
import { OutcomeBuilder } from "./outcome-builder";
import { ParallelStepBuilder } from "./parallel-step-builder";
export declare class StepBuilder<TStepBody extends StepBody, TData> {
    private workflowBuilder;
    step: WorkflowStep<TStepBody>;
    constructor(workflowBuilder: WorkflowBuilder<TData>, step: WorkflowStep<TStepBody>);
    name(name: string): StepBuilder<TStepBody, TData>;
    then<TNewStepBody extends StepBody>(body: {
        new (): TNewStepBody;
    }, setup?: (step: StepBuilder<TNewStepBody, TData>) => void): StepBuilder<TNewStepBody, TData>;
    thenStep<TNewStepBody extends StepBody>(newStep: StepBuilder<TNewStepBody, TData>): StepBuilder<TNewStepBody, TData>;
    thenRun(step: (context: StepExecutionContext) => Promise<ExecutionResult>): StepBuilder<InlineStepBody, TData>;
    when(outcomeValue: (data: TData) => any): OutcomeBuilder<TData>;
    input(expression: (step: TStepBody, data: TData) => void): StepBuilder<TStepBody, TData>;
    output(expression: (step: TStepBody, data: TData) => void): StepBuilder<TStepBody, TData>;
    waitFor(eventName: string, eventKey: (data: TData) => any, effectiveDate?: (data: TData) => Date): StepBuilder<WaitFor, TData>;
    end<TNewStepBody extends StepBody>(stepName: string): StepBuilder<TNewStepBody, TData>;
    onError(behavior: number, retryInterval?: number): StepBuilder<TStepBody, TData>;
    private iterateParents(id, name);
    foreach(expression: (data: TData) => any[]): StepBuilder<Foreach, TData>;
    while(expression: (data: TData) => boolean): StepBuilder<While, TData>;
    if(expression: (data: TData) => boolean): StepBuilder<If, TData>;
    parallel(): ParallelStepBuilder<TData, Sequence>;
    saga(builder: (then: WorkflowBuilder<TData>) => void): StepBuilder<Sequence, TData>;
    schedule(interval: (data: TData) => number): ReturnStepBuilder<TData, Schedule, TStepBody>;
    delay(milliseconds: (data: TData) => number): StepBuilder<Delay, TData>;
    compensateWith<TNewStepBody extends StepBody>(body: {
        new (): TNewStepBody;
    }, setup?: (step: StepBuilder<TNewStepBody, TData>) => void): StepBuilder<TStepBody, TData>;
    compensateWithSequence(sequence: (then: WorkflowBuilder<TData>) => void): StepBuilder<TStepBody, TData>;
    do(builder: (then: WorkflowBuilder<TData>) => void): StepBuilder<TStepBody, TData>;
}