import { StreamIO } from '../data';
import { ArrayType, BooleanType, DictType, EastFunction, EastType, ProcedureFunction, SetType, StringType, StructType, VariantType } from '../east';
import { MLDescription } from '../scenario/SimulationTaskDescription';
import { ModulePath } from '../template';
/** @internal */
export type LetFunctionStatement = {
    type: "let";
    name: string;
    expr: EastFunction;
};
/** @internal */
export type AssignFunctionStatement = {
    type: "assign";
    name: string;
    expr: EastFunction;
};
/** @internal */
export type InsertFunctionStatement = {
    type: "insert";
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: "first" | "last" | EastFunction;
    value: EastFunction | null;
    if_exists: 'error' | 'warn' | 'ignore';
};
/** @internal */
export type UpdateFunctionStatement = {
    type: "update";
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: EastFunction;
    value: EastFunction;
    old_value: string;
};
/** @internal */
export type DeleteFunctionStatement = {
    type: "delete";
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: "first" | "last" | EastFunction;
    if_not_exists: 'error' | 'warn' | 'ignore';
};
/** @internal */
export type ClearFunctionStatement = {
    type: "clear";
    collection: EastFunction<ArrayType | SetType | DictType>;
};
/** @internal */
export type IfFunctionStatement = {
    type: "if";
    predicate: EastFunction<BooleanType>;
    true_statements: FunctionStatement[];
    false_statements: FunctionStatement[];
};
/** @internal */
export type IfNullFunctionStatement = {
    type: "ifNull";
    label: string;
    input: EastFunction;
    null_statements: FunctionStatement[];
    value_statements: FunctionStatement[];
};
/** @internal */
export type MatchFunctionStatement = {
    type: "match";
    label: string;
    variant: EastFunction<VariantType>;
    case_statements: Record<string, FunctionStatement[]>;
};
/** @internal */
export type WhileFunctionStatement = {
    type: "while";
    label: string;
    predicate: EastFunction<BooleanType>;
    statements: FunctionStatement[];
};
/** @internal */
export type ForFunctionStatement = {
    type: "for";
    label: string;
    collection: EastFunction<ArrayType | DictType | SetType>;
    statements: FunctionStatement[];
};
/** @internal */
export type ContinueFunctionStatement = {
    type: "continue";
    label: string;
};
/** @internal */
export type BreakFunctionStatement = {
    type: "break";
    label: string;
};
/** @internal */
export type LogFunctionStatement = {
    type: "log";
    message: EastFunction<StringType>;
};
/** @internal */
export type WarnFunctionStatement = {
    type: "warn";
    message: EastFunction<StringType>;
};
/** @internal */
export type ErrorFunctionStatement = {
    type: "error";
    message: EastFunction<StringType>;
};
/** @internal */
export type ReturnFunctionStatement = {
    type: "return";
    outputs: Record<string, EastFunction>;
};
/** @internal */
export type RecurseFunctionStatement = {
    type: "recurse";
    name: string;
    inputs: Record<string, EastFunction>;
};
/** @internal */
export type ReturnProcedureStatement = {
    type: "return_procedure";
    output: EastFunction;
};
/** @internal */
export type FunctionStatement = LetFunctionStatement | AssignFunctionStatement | InsertFunctionStatement | UpdateFunctionStatement | DeleteFunctionStatement | ClearFunctionStatement | IfFunctionStatement | IfNullFunctionStatement | MatchFunctionStatement | WhileFunctionStatement | ForFunctionStatement | ContinueFunctionStatement | BreakFunctionStatement | LogFunctionStatement | WarnFunctionStatement | ErrorFunctionStatement | ReturnFunctionStatement | RecurseFunctionStatement | ReturnProcedureStatement;
/** @internal */
export type ProcedureDescription<Name extends string = string, Inputs extends StructType = StructType, T extends EastType = EastType> = {
    name: Name;
    inputs: Inputs;
    output: T;
    procedures: Record<string, {
        inputs: StructType;
        output: EastType;
    }>;
    statements: FunctionStatement[];
};
/** @internal */
export type ProcedureEvaluator<Proc extends ProcedureDescription> = (inputs: EastFunction<Proc["inputs"]>) => EastFunction<Proc["output"]>;
/** @internal */
export declare function ProcedureEvaluator<Proc extends ProcedureDescription>(proc: Proc): ProcedureEvaluator<Proc>;
/** @internal */
export declare function createProcedureAST(proc: ProcedureDescription, inputs: EastFunction<StructType>): ProcedureFunction;
/** @internal */
export declare function procedureEqual(proc1: ProcedureDescription, proc2: ProcedureDescription): boolean;
/** @internal */
export type FunctionTaskDescription = {
    task_type: "function";
    module: ModulePath;
    name: string;
    inputs: Record<string, StreamIO>;
    defaults: Record<string, EastFunction>;
    mls: Record<string, MLDescription>;
    procedures: Record<string, ProcedureDescription>;
    outputs: Record<string, StreamIO>;
    statements: FunctionStatement[];
    random_seed: string;
};