import { IExecutorEngine, ExecutionResult } from "../engines/base";
import { WorkflowParamTypes } from "../../models/parameters";
import { Output as NodeOutput } from '../../models/workflowNode';
export interface IStatementTranslator<InputT, OutputT> {
    translateFromInput(input: InputT): string;
    translateToOutput(input: InputT, executionResult: ExecutionResult): OutputT;
}
export declare namespace StatementExecutor {
    interface IInput {
        id: string;
    }
}
export declare abstract class StatementExecutor<InputT extends StatementExecutor.IInput, OutputT> {
    protected abstract readonly translator: IStatementTranslator<InputT, OutputT>;
    private readonly input;
    constructor(input: InputT);
    execute(engine: IExecutorEngine): Promise<OutputT>;
}
export interface InputBinding {
    fromOutputName: string;
    fromOutputNodeId: string;
    toInputName: string;
}
export declare namespace CodeStatement {
    interface Input extends StatementExecutor.IInput {
        params: WorkflowParamTypes[];
        inputs: InputBinding[];
        code: string;
    }
    interface Output {
        id: string;
    }
}
export declare abstract class CodeStatement extends StatementExecutor<CodeStatement.Input, CodeStatement.Output> {
}
export declare namespace IntrospectStatement {
    interface Input extends StatementExecutor.IInput {
        resultId: string;
    }
    interface Output {
        output: NodeOutput;
    }
}
export declare abstract class IntrospectStatement extends StatementExecutor<IntrospectStatement.Input, IntrospectStatement.Output> {
}
export declare namespace RequestTableDataStatement {
    interface Input extends StatementExecutor.IInput {
        outputId: string;
        name: string;
        ix: [number, number];
        iy: [number, number];
    }
    interface Output {
        output: any[][];
    }
}
export declare abstract class RequestTableDataStatement extends StatementExecutor<RequestTableDataStatement.Input, RequestTableDataStatement.Output> {
}
export declare namespace InitializeStatement {
    interface Input extends StatementExecutor.IInput {
    }
}
export declare abstract class InitializeStatement extends StatementExecutor<InitializeStatement.Input, void> {
}
export interface IStatementFactory {
    Introspect(input: IntrospectStatement.Input): IntrospectStatement;
    Code(input: CodeStatement.Input): CodeStatement;
    RequestTableData(input: RequestTableDataStatement.Input): RequestTableDataStatement;
    Initialize(input: InitializeStatement.Input): InitializeStatement;
}