import { Stream, StreamIO } from "../data/Stream";
import { ArrayType, BlobType, BooleanType, DictType, EastFunction, EastType, FloatType, MLFunction, Nullable, SetType, StringType, StructType, VariantType } from "../east";
import { ProcedureDescription } from '../function';
import { MLModel, MLPredictionConfiguration } from '../ml';
import type { ModulePath } from '../template/Module';
import { OptimizationAlgorithm } from './optimization';
/** @internal */
export type ResourceDescription<T extends EastType> = {
    name: string;
    type: T;
    input: string;
    description: any | null;
};
/** @internal */
export type MLDescription<Features extends StructType = StructType, T extends EastType = EastType> = {
    name: string;
    output_type: T;
    features_type: Features;
    model: MLModel;
    input: string;
    modelStream: Stream;
};
/** @internal */
export type MLEvaluator<ML extends MLDescription> = (features: EastFunction<ML["features_type"]>, config?: Partial<MLPredictionConfiguration<ML["output_type"]>>) => EastFunction<ML["output_type"]>;
/** @internal */
export declare function MLEvaluator<ML extends MLDescription>(ml: ML): MLEvaluator<ML>;
/** @internal */
export declare function createMLAST(ml: MLDescription, features: EastFunction<StructType>, config?: Record<string, EastFunction>): MLFunction;
/** @internal */
export declare function mlEqual(ml1: MLDescription, ml2: MLDescription): boolean;
/** @internal */
export type Statement = {
    type: "comment";
    comment: string;
} | {
    type: "let";
    name: string;
    expr: EastFunction;
    schema?: any;
} | {
    type: "assign";
    name: string;
    expr: EastFunction;
} | {
    type: "error";
    message: EastFunction<StringType>;
} | {
    type: "warn";
    message: EastFunction<StringType>;
} | {
    type: "log";
    message: EastFunction<StringType>;
} | {
    type: "set";
    resource: string;
    expr: EastFunction;
} | {
    type: "insert";
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: "first" | "last" | EastFunction;
    value?: EastFunction;
    if_exists: 'error' | 'warn' | 'ignore';
} | {
    type: "update";
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: EastFunction;
    value: EastFunction;
    old_value: string;
} | {
    type: "delete";
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: "first" | "last" | EastFunction;
    if_not_exists: 'error' | 'warn' | 'ignore';
} | {
    type: "clear";
    collection: EastFunction<ArrayType | SetType | DictType>;
} | {
    type: "execute";
    process: string;
    values: EastFunction<StructType>;
} | {
    type: "if";
    predicate: EastFunction<BooleanType>;
    true_block: Statement[];
    false_block: Statement[];
} | {
    type: "ifNull";
    input: EastFunction<Nullable>;
    null_block: Statement[];
    value_block: Statement[];
    value: string;
} | {
    type: "match";
    variant: EastFunction<VariantType>;
    cases: Record<string, Statement[]>;
    data: string;
} | {
    type: "while";
    label: string;
    predicate: EastFunction<BooleanType>;
    block: Statement[];
} | {
    type: "for";
    label: string;
    collection: EastFunction<ArrayType | SetType | DictType>;
    key: string;
    value: string | null;
    block: Statement[];
} | {
    type: "continue";
    label: string;
} | {
    type: "break";
    label: string;
} | {
    type: "end";
    predicate: EastFunction<BooleanType>;
};
/** @internal */
export type ProcessDescription<T extends StructType, V extends StructType> = {
    name: string;
    values: V;
    type: T;
    description: string | null;
    statements: Statement[];
    input: string | null;
};
/** @internal */
export type SimulationConfiguration = {
    trajectories: null | number;
    in_memory: boolean;
    journal: boolean;
    queue: boolean;
    debug: boolean;
};
/** @internal */
export type SimulationTaskDescription = {
    task_type: "simulation";
    module: ModulePath;
    name: string;
    inputs: Record<string, StreamIO>;
    outputs: Record<string, StreamIO>;
    resources: Record<string, ResourceDescription<EastType>>;
    processes: Record<string, ProcessDescription<StructType, StructType>>;
    mls: Record<string, MLDescription>;
    procedures: Record<string, ProcedureDescription>;
    results: Record<string, EastFunction>;
    configuration: SimulationConfiguration;
    initial_queue: string | null;
    end_date: string | null;
    random_seed: string;
};
/** @internal */
export type Optimization = {
    optimization_type: "set";
    resource: string;
    transform: EastFunction;
} | {
    optimization_type: "update";
    resource: string;
    field: string;
    active: EastFunction<BooleanType>;
    transform: EastFunction;
};
/** @internal */
export type OptimizationConfiguration = {
    trajectories: null | number;
    max_iterations: number;
    min_iterations: number;
    rtol: number;
    atol: number;
    threads: boolean;
    in_memory: boolean;
    optimization_algorithm: OptimizationAlgorithm;
};
/** @internal */
export type OptimizationTaskDescription = {
    task_type: "optimization";
    module: ModulePath;
    name: string;
    inputs: Record<string, StreamIO>;
    outputs: Record<string, StreamIO>;
    resources: Record<string, ResourceDescription<EastType>>;
    processes: Record<string, ProcessDescription<StructType, StructType>>;
    mls: Record<string, MLDescription>;
    procedures: Record<string, ProcedureDescription>;
    objective: EastFunction<FloatType>;
    optimizations: Optimization[];
    configuration: OptimizationConfiguration;
    initial_queue: string | null;
    end_date: string | null;
    random_seed: string;
};
/** @internal */
export type CustomOptimizationConfiguration = {
    trajectories: number;
    max_iterations: number;
    min_iterations: number;
    rtol: number;
    atol: number;
    in_memory: boolean;
    optimization_algorithm: OptimizationAlgorithm;
};
/** @internal */
export type CustomOptimizationTaskDescription = {
    task_type: "custom_optimization";
    module: ModulePath;
    name: string;
    inputs: Record<string, StreamIO>;
    outputs: Record<string, StreamIO>;
    results: Record<string, EastFunction>;
    image: string | null;
    mountDir: string;
    inputFiles: {
        input: string;
        path: string;
        executable: boolean;
        toBlob: EastFunction<BlobType>;
    }[];
    outputFiles: {
        path: string;
        fromBlob: EastFunction;
    }[];
    command: string[] | null;
    objective: EastFunction<FloatType>;
    optimizations: Optimization[];
    configuration: CustomOptimizationConfiguration;
    logStdOut: boolean;
    logStdErr: boolean;
    envs: Record<string, EastFunction<StringType>>;
    simulationTrajectories: number | null;
};