import { Upgradable } from "./metaes";
import { FunctionNode } from "./nodeTypes";
export declare type MetaesException = {
    type: "Error" | "ReturnStatement" | "BreakStatement" | "ContinueStatement";
    message?: string;
    location?: ASTNode;
    script?: Script;
    value?: Error | any | MetaesException;
};
export declare type Range = [number, number];
export declare type ScriptType = "script" | "module";
export declare type Script = {
    ast: ASTNode;
    source: Source;
    scriptId: string;
    url?: string;
    type?: ScriptType;
};
export declare type NonEvaluableValue = undefined | boolean | number | boolean | symbol | any[] | object;
export declare type Source = string | ASTNode | Function;
export declare type EvalParam = Script | Source | NonEvaluableValue;
declare type Continuations<C = any, E = ErrorContinuation> = [Continuation<C>, E];
declare type Rest<U = false, C = Partial<EvaluationConfig>> = [
    Environment | EnvironmentBase | object,
    U extends true ? Upgradable<C> : C
];
declare type Builder<I, C extends any[], R extends any[]> = [I, ...C, ...R];
/**
 * All params are required.
 */
export declare type Evaluate<C = any, I = EvalParam> = (...args: Builder<I, Continuations<C>, [Environment, EvaluationConfig]>) => void;
/**
 * Only input is required.
 */
export declare type EvaluateBase<C = any, I = EvalParam, U = false> = (...args: Builder<I, Partial<Continuations<C>>, Partial<Rest<U>>>) => void;
/**
 * Environment and config are optional.
 */
export declare type EvaluateMid<C = any, I = EvalParam, U = false> = (...args: Builder<I, Continuations<C>, Partial<Rest<U>>>) => void;
/**
 * Used in client code, config param accepts upgrade function.
 */
export declare type EvaluateClient<C = any, I = EvalParam, U = false> = (...args: Builder<I, Continuations<C>, Partial<Rest<U>>>) => void;
export declare type Phase = "enter" | "exit";
export interface Evaluation {
    e: ASTNode;
    value: any;
    phase: Phase;
    config: EvaluationConfig;
    timestamp: number;
    env: Environment;
}
export declare type Interceptor = (evaluation: Evaluation) => void;
declare type Schedule = (task: () => void) => void;
export interface EvaluationConfig {
    interceptor?: Interceptor;
    interpreters: Environment<Interpreter<any>>;
    script: Script;
    schedule: Schedule;
}
export declare type Optional<T> = {
    boxed: T;
};
export declare type Continuation<T = any> = T extends undefined ? () => void : T extends Optional<infer I> ? (value?: I) => void : (value: T) => void;
export declare type ErrorContinuation = (error: MetaesException) => void;
export declare type PartialErrorContinuation = (error: Pick<MetaesException, "type"> & Partial<MetaesException>) => void;
export declare type Interpreter<T extends ASTNode | ASTNode[] | object> = (...args: Builder<T, [(value?: any) => void, PartialErrorContinuation], [Environment, EvaluationConfig]>) => void;
export declare type Interpreters = {
    [key: string]: Interpreter<any>;
};
export declare type MetaesFunction = {
    e: FunctionNode;
    closure: Environment;
    config: EvaluationConfig;
    prev?: MetaesFunction;
};
export interface NodeLoc {
    start: {
        column: number;
        line: number;
    };
    end: {
        column: number;
        line: number;
    };
}
declare type Position = {
    loc?: NodeLoc;
    range?: [number, number];
};
export declare type NodeBase = Position;
export declare type ASTNode = NodeBase & {
    type: string | any;
    [key: string]: any;
};
export interface EnvironmentBase<T = any> {
    values: {
        [key: string]: T;
    };
}
export interface Environment<T = any> extends EnvironmentBase<T> {
    prev?: Environment<T>;
    /**
     * If true, then user code won't save values in this environment.
     */
    internal?: boolean;
    [key: string]: any;
}
export {};