import ParsingContext from './parsing_context';
import EvaluationContext from './evaluation_context';
import type { Expression, ExpressionRegistry } from './expression';
import type { Type } from './types';
import type { Value } from './values';
export declare type Varargs = {
    type: Type;
};
declare type Signature = Array<Type> | Varargs;
declare type Evaluate = (b: EvaluationContext, a: Array<Expression>) => Value;
declare type Definition = [Type, Signature, Evaluate] | {
    type: Type;
    overloads: Array<[Signature, Evaluate]>;
};
declare class CompoundExpression implements Expression {
    name: string;
    type: Type;
    _evaluate: Evaluate;
    args: Array<Expression>;
    static definitions: {
        [_: string]: Definition;
    };
    constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>);
    evaluate(ctx: EvaluationContext): Value;
    eachChild(fn: (_: Expression) => void): void;
    outputDefined(): boolean;
    serialize(): Array<unknown>;
    static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression | undefined | null;
    static register(registry: ExpressionRegistry, definitions: {
        [_: string]: Definition;
    }): void;
}
export default CompoundExpression;
//# sourceMappingURL=compound_expression.d.ts.map