import { FunctionType, VoidType, CompleteObjectType, ReferenceType, AtomicType, CompleteClassType, CompleteReturnType, ReferredType } from "./types";
import { RuntimeConstruct } from "../constructs/CPPConstruct";
import { CompiledFunctionDefinition } from "../constructs/declarations/function/FunctionDefinition";
import { MemoryFrame } from "../runtime/Memory";
import { CPPObject } from "../runtime/objects";
import { RuntimeBlock } from "../constructs/statements/Block";
import { Simulation } from "../runtime/Simulation";
import { RuntimeCtorInitializer } from "../constructs/initializers/CtorInitializer";
import { RuntimeFunctionCall } from "../constructs/FunctionCall";
import { RuntimeObjectDeallocator } from "../constructs/ObjectDeallocator";
export declare class RuntimeFunction<T extends FunctionType<CompleteReturnType> = FunctionType<CompleteReturnType>> extends RuntimeConstruct<CompiledFunctionDefinition<T>> {
    readonly caller?: RuntimeFunctionCall;
    readonly stackFrame?: MemoryFrame;
    readonly receiver?: CPPObject<CompleteClassType>;
    /**
     * The object returned by the function, either an original returned-by-reference or a temporary
     * object created to hold a return-by-value. Once the function call has been executed, will be
     * defined unless it's a void function.
     */
    readonly returnObject?: T extends FunctionType<infer RT> ? (RT extends VoidType ? undefined : RT extends CompleteObjectType ? CPPObject<RT> : RT extends ReferenceType<CompleteObjectType> ? CPPObject<ReferredType<RT>> : never) : never;
    readonly hasControl: boolean;
    readonly ctorInitializer?: RuntimeCtorInitializer;
    readonly body: RuntimeBlock;
    /**
     * Only defined for destructors. A runtime deallocator for the member
     * variables of the receiver that is set as the cleanup construct for
     * this RuntimeFunction.
     */
    readonly memberDeallocator?: RuntimeObjectDeallocator;
    constructor(model: CompiledFunctionDefinition<T>, sim: Simulation, caller: RuntimeFunctionCall | null, receiver?: CPPObject<CompleteClassType>);
    pushStackFrame(): void;
    popStackFrame(): void;
    /**
     * Sets the return object for this function. May only be invoked once.
     * e.g.
     *  - return-by-value: The caller should set the return object to a temporary object, whose value
     *                     may be initialized by a return statement.
     *  - return-by-reference: When the function is finished, is set to the object returned.
     */
    setReturnObject<T extends FunctionType<AtomicType | CompleteClassType>>(this: RuntimeFunction<T>, obj: CPPObject<T["returnType"]>): void;
    setReturnObject<T extends ReferenceType<CompleteObjectType>>(this: RuntimeFunction<FunctionType<T>>, obj: CPPObject<ReferredType<T>>): void;
    getParameterObject(num: number): import("../runtime/objects").AutoObject<CompleteObjectType>;
    bindReferenceParameter(num: number, obj: CPPObject): void;
    gainControl(): void;
    loseControl(): void;
    protected stepForwardImpl(): void;
    protected upNextImpl(): void;
}