import { Predicate, UnificationEnvironment } from "../logic";
import { CrochetValue } from "../primitives";
import { Machine, State } from "../vm";
import { Metadata } from "./meta";
import { SBlock, Statement } from "./statement";
import { Type } from "./type";
export declare abstract class Expression {
    abstract evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
    map_subexpressions(f: (_: Expression) => Expression): Expression;
    abstract get position(): Metadata;
}
export declare class EFalse extends Expression {
    readonly position: Metadata;
    constructor(position: Metadata);
    evaluate(state: State): Machine;
}
export declare class ETrue extends Expression {
    readonly position: Metadata;
    constructor(position: Metadata);
    evaluate(state: State): Machine;
}
export declare class EVariable extends Expression {
    readonly position: Metadata;
    readonly name: string;
    constructor(position: Metadata, name: string);
    evaluate(state: State): Machine;
}
export declare class EText extends Expression {
    readonly position: Metadata;
    readonly value: string;
    constructor(position: Metadata, value: string);
    evaluate(state: State): Machine;
}
export declare class EInteger extends Expression {
    readonly position: Metadata;
    readonly value: bigint;
    constructor(position: Metadata, value: bigint);
    evaluate(state: State): Machine;
}
export declare class ESearch extends Expression {
    readonly position: Metadata;
    readonly predicate: Predicate;
    constructor(position: Metadata, predicate: Predicate);
    evaluate(state: State): Machine;
}
export declare class EInvoke extends Expression {
    readonly position: Metadata;
    readonly name: string;
    readonly args: Expression[];
    constructor(position: Metadata, name: string, args: Expression[]);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
    map_subexpressions(f: (_: Expression) => Expression): EInvoke;
}
export declare class ENew extends Expression {
    readonly position: Metadata;
    readonly name: string;
    readonly data: Expression[];
    constructor(position: Metadata, name: string, data: Expression[]);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
}
export declare class EGlobal extends Expression {
    readonly position: Metadata;
    readonly name: string;
    constructor(position: Metadata, name: string);
    evaluate(state: State): Machine;
}
export declare class ESelf extends Expression {
    readonly position: Metadata;
    constructor(position: Metadata);
    evaluate(state: State): Machine;
}
export declare class EList extends Expression {
    readonly position: Metadata;
    readonly values: Expression[];
    constructor(position: Metadata, values: Expression[]);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
}
export declare abstract class RecordField {
    get expression(): Expression;
    get name(): string;
    abstract is_static: boolean;
}
export declare class RFStatic extends RecordField {
    readonly _name: string;
    constructor(_name: string);
    get is_static(): boolean;
    get name(): string;
}
export declare class RFDynamic extends RecordField {
    readonly value: Expression;
    constructor(value: Expression);
    get is_static(): boolean;
    get expression(): Expression;
}
export declare class ERecord extends Expression {
    readonly position: Metadata;
    readonly pairs: {
        key: RecordField;
        value: Expression;
    }[];
    constructor(position: Metadata, pairs: {
        key: RecordField;
        value: Expression;
    }[]);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
}
export declare class EProject extends Expression {
    readonly position: Metadata;
    readonly object: Expression;
    readonly field: RecordField;
    constructor(position: Metadata, object: Expression, field: RecordField);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
}
export declare class EProjectMany extends Expression {
    readonly position: Metadata;
    readonly object: Expression;
    readonly fields: {
        key: RecordField;
        alias: RecordField;
    }[];
    constructor(position: Metadata, object: Expression, fields: {
        key: RecordField;
        alias: RecordField;
    }[]);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
}
export declare abstract class ForallExpr {
    abstract evaluate(state: State, results: CrochetValue[]): Machine;
}
export declare class ForallMap extends ForallExpr {
    readonly name: string;
    readonly stream: Expression;
    readonly body: ForallExpr;
    constructor(name: string, stream: Expression, body: ForallExpr);
    evaluate(state: State, results: CrochetValue[]): Machine;
}
export declare class ForallDo extends ForallExpr {
    readonly body: Expression;
    constructor(body: Expression);
    evaluate(state: State, results: CrochetValue[]): Machine;
}
export declare class ForallIf extends ForallExpr {
    readonly condition: Expression;
    readonly body: ForallExpr;
    constructor(condition: Expression, body: ForallExpr);
    evaluate(state: State, results: CrochetValue[]): Machine;
}
export declare class EForall extends Expression {
    readonly position: Metadata;
    readonly expr: ForallExpr;
    constructor(position: Metadata, expr: ForallExpr);
    evaluate(state: State): Machine;
    evaluate_stream(state: State, expr: Expression): Generator<never, void, unknown>;
}
export declare class EBlock extends Expression {
    readonly position: Metadata;
    readonly body: Statement[];
    constructor(position: Metadata, body: Statement[]);
    evaluate(state: State): Machine;
}
export declare class EPartial extends Expression {
    readonly position: Metadata;
    readonly name: string;
    readonly values: PartialExpr[];
    constructor(position: Metadata, name: string, values: PartialExpr[]);
    evaluate(state: State): Machine;
}
export declare class EApply extends Expression {
    readonly position: Metadata;
    readonly partial: Expression;
    readonly values: PartialExpr[];
    constructor(position: Metadata, partial: Expression, values: PartialExpr[]);
    evaluate(state: State): Machine;
}
export declare abstract class PartialExpr {
    abstract evaluate(state: State): Machine;
}
export declare class EPartialHole extends PartialExpr {
    evaluate(state: State): Machine;
}
export declare class EPartialConcrete extends PartialExpr {
    readonly expr: Expression;
    constructor(expr: Expression);
    evaluate(state: State): Machine;
}
export declare class EInterpolate extends Expression {
    readonly position: Metadata;
    readonly parts: EInterpolationPart[];
    constructor(position: Metadata, parts: EInterpolationPart[]);
    evaluate(state: State): Machine;
}
export declare type EInterpolationPart = EInterpolateStatic | EInterpolateDynamic;
export declare class EInterpolateStatic {
    readonly text: string;
    constructor(text: string);
    evaluate(state: State): Machine;
}
export declare class EInterpolateDynamic {
    readonly expr: Expression;
    constructor(expr: Expression);
    evaluate(state: State): Machine;
}
export declare class EMatchSearch extends Expression {
    readonly position: Metadata;
    readonly cases: MatchSearchCase[];
    constructor(position: Metadata, cases: MatchSearchCase[]);
    evaluate(state: State): Machine;
}
export declare class MatchSearchCase {
    readonly predicate: Predicate;
    readonly body: SBlock;
    constructor(predicate: Predicate, body: SBlock);
    search(state: State): UnificationEnvironment[];
}
export declare class ECondition extends Expression {
    readonly position: Metadata;
    readonly cases: ConditionCase[];
    constructor(position: Metadata, cases: ConditionCase[]);
    evaluate(state: State): Machine;
}
export declare class ConditionCase {
    readonly test: Expression;
    readonly body: SBlock;
    constructor(test: Expression, body: SBlock);
}
export declare class EHasType extends Expression {
    readonly position: Metadata;
    readonly value: Expression;
    readonly type: Type;
    constructor(position: Metadata, value: Expression, type: Type);
    evaluate(state: State): Machine;
}
export declare class ELazy extends Expression {
    readonly position: Metadata;
    readonly value: Expression;
    constructor(position: Metadata, value: Expression);
    evaluate(state: State): Machine;
}
export declare class EForce extends Expression {
    readonly position: Metadata;
    readonly value: Expression;
    constructor(position: Metadata, value: Expression);
    evaluate(state: State): Machine;
}
export declare class EReturn extends Expression {
    readonly position: Metadata;
    constructor(position: Metadata);
    evaluate(state: State): Machine;
}
export declare class EStaticType extends Expression {
    readonly position: Metadata;
    readonly type: Type;
    constructor(position: Metadata, type: Type);
    evaluate(state: State): Machine;
}
export declare class EFloat extends Expression {
    readonly position: Metadata;
    readonly value: number;
    constructor(position: Metadata, value: number);
    evaluate(state: State): Machine;
}
export declare class ELambda extends Expression {
    readonly position: Metadata;
    readonly parameters: string[];
    readonly body: Expression;
    constructor(position: Metadata, parameters: string[], body: Expression);
    evaluate(state: State): Machine;
}
export declare class EIntrinsicEqual extends Expression {
    readonly position: Metadata;
    readonly left: Expression;
    readonly right: Expression;
    constructor(position: Metadata, left: Expression, right: Expression);
    evaluate(state: State): Machine;
    get sub_expressions(): Expression[];
    map_subexpressions(f: (_: Expression) => Expression): EIntrinsicEqual;
}
export declare class ENothing extends Expression {
    readonly position: Metadata;
    constructor(position: Metadata);
    evaluate(state: State): Machine;
}