import { type Environment } from "../../env";
import { type Expr, type FnCallExpr } from "../../expr";
import type { FunctionParameter, FunctionType, Type } from "../../types/definitions";
import type { EvaluatorContext } from "../context";
export declare function evaluateFunctionParameter({ expr, env, context, isParameterComptimeByDefault, allowVariableShadowing, }: {
    expr: Expr;
    env: Environment;
    context: EvaluatorContext & {
        isEvaluatingFunctionType: true;
    };
    isParameterComptimeByDefault: boolean;
    allowVariableShadowing: boolean;
}): {
    parameter: FunctionParameter;
    env: Environment;
};
export declare function applyWhereClauseConstraints({ constraintExprs, env, context, }: {
    constraintExprs: Expr[];
    env: Environment;
    context: EvaluatorContext & {
        isEvaluatingFunctionType: true;
    };
}): {
    env: Environment;
};
export declare function evaluateFunctionParameters({ parameterExprs, env, context, }: {
    parameterExprs: Expr[];
    env: Environment;
    context: EvaluatorContext & {
        isEvaluatingFunctionType: true;
    };
}): {
    parameters: FunctionParameter[];
    forallParameters: FunctionParameter[];
    variadicParameter?: FunctionParameter;
    whereClauseExprs?: Expr[];
    requiresExprs?: Expr[];
    ensuresExprs?: Expr[];
    env: Environment;
};
export declare function evaluateFunctionType({ expr, env, context, }: {
    expr: FnCallExpr;
    env: Environment;
    context: EvaluatorContext;
}): FnCallExpr;
export declare function evaluateFunctionParameterTypeAgain({ parameter, calleeEnv, context, definitionSiteEnclosingFunctionType, functionType, }: {
    parameter: FunctionParameter;
    calleeEnv: Environment;
    context: EvaluatorContext & {
        isEvaluatingFunctionType: true;
    };
    definitionSiteEnclosingFunctionType?: FunctionType;
    functionType: FunctionType;
}): {
    parameterType: Type;
    calleeEnv: Environment;
};
export declare function evaluateFunctionReturnTypeAgain({ functionType, calleeEnv, context, functionCalleeExpr, }: {
    functionType: FunctionType;
    calleeEnv: Environment;
    context: EvaluatorContext & {
        isEvaluatingFunctionType: true;
    };
    functionCalleeExpr?: Expr;
}): {
    returnType: Type;
    calleeEnv: Environment;
};
