import { Expression, Metadata, Statement } from "../ir";
import { CrochetValue } from "../primitives";
import { MachineError } from "./errors/errors";
import type { State } from "./state";
export declare class CrochetError {
    readonly error: MachineError;
    readonly trace: StackTrace;
    constructor(error: MachineError, trace: StackTrace);
    get message(): string;
    get stack(): string;
}
export declare abstract class Yield {
    abstract evaluate(thread: Thread): SyncReturn | void;
}
export declare class Push extends Yield {
    readonly machine: Machine;
    constructor(machine: Machine);
    evaluate(thread: Thread): void;
}
export declare class PushExpr extends Yield {
    readonly expr: Expression | Statement;
    readonly state: State;
    constructor(expr: Expression | Statement, state: State);
    evaluate(thread: Thread): void;
}
export declare class Jump extends Yield {
    readonly machine: Machine;
    constructor(machine: Machine);
    evaluate(thread: Thread): void;
}
export declare class Mark extends Yield {
    readonly name: string;
    readonly machine: Machine;
    readonly k: Machine | null;
    constructor(name: string, machine: Machine, k: Machine | null);
    evaluate(thread: Thread): void;
}
export declare class Await extends Yield {
    readonly value: Promise<unknown>;
    constructor(value: Promise<unknown>);
    evaluate(thread: Thread): SRAwait;
}
export declare function _await(value: Promise<unknown>): Await;
export declare function _push(machine: Machine): Push;
export declare function _push_expr(expr: Expression | Statement, state: State): PushExpr;
export declare function _jump(machine: Machine): Jump;
export declare function _mark(name: string, machine: Machine, k?: Machine | null): Mark;
export declare abstract class Frame {
    abstract evaluate(value: unknown, thread: Thread): void;
}
declare class FExpression extends Frame {
    readonly expr: Expression | Statement;
    readonly state: State;
    readonly machine: Machine;
    constructor(expr: Expression | Statement, state: State, machine: Machine);
    get location(): {
        position: Metadata;
        filename: string;
    };
    evaluate(value: unknown, thread: Thread): void;
}
declare class FProcedure extends Frame {
    readonly location: string;
    readonly k: Machine;
    constructor(location: string, k: Machine);
    evaluate(value: unknown, thread: Thread): void;
}
declare type SyncReturn = SRAwait | SRDone;
declare class SRAwait {
    readonly value: Promise<unknown>;
    readonly thread: Thread;
    readonly tag = "await";
    constructor(value: Promise<unknown>, thread: Thread);
}
declare class SRDone {
    readonly value: unknown;
    readonly tag = "done";
    constructor(value: unknown);
}
export declare class Thread {
    stack: Frame[];
    machine: Machine;
    input: unknown;
    current: {
        position: Metadata;
        filename: string;
    } | null;
    private constructor();
    static for_machine(machine: Machine): Thread;
    static for_expr(expr: Expression | Statement, state: State): Thread;
    get stack_frames(): StackFrames;
    save_machine(): void;
    unwind_to_procedure(): FProcedure | null;
    run(): SyncReturn;
    run_sync(): unknown;
    run_and_wait(): Promise<unknown>;
    die(message: string): void;
}
export declare class StackFrames {
    private _frames;
    constructor(_frames: Frame[]);
    frames(): Generator<Frame, void, unknown>;
    get current_expression_frame(): FExpression | null;
    get stack_trace(): StackTrace;
}
export declare class StackTrace {
    readonly location: {
        position: Metadata;
        filename: string;
    } | null;
    readonly trace: string[];
    constructor(location: {
        position: Metadata;
        filename: string;
    } | null, trace: string[]);
    format_location(): string[];
    format_trace(): string[];
    format(): string;
}
export declare type Machine = Generator<Yield, unknown, unknown>;
export declare function run_all(machines: Machine[]): Machine;
export declare function run_all_exprs(exprs: (Statement | Expression)[], state: State): Machine;
export declare function cvalue(x: unknown): CrochetValue;
export declare function avalue(x: unknown): CrochetValue[];
export declare function die(x: string): never;
export {};