/// <reference types="jquery" />
/// <reference types="bootstrap" />
import { Simulation } from "../../runtime/Simulation";
import { AtomicType } from "../../compilation/types";
import { ExpressionContext, ConstructDescription, SemanticContext } from "../../compilation/contexts";
import { SuccessfullyCompiled, RuntimeConstruct } from "../CPPConstruct";
import { Expression, CompiledExpression, TypedExpression, t_TypedExpression } from "./Expression";
import { RuntimeExpression } from "./RuntimeExpression";
import { AssignmentExpressionOutlet } from "../../../view/constructs/ExpressionOutlets";
import { ConstructOutlet } from "../../../view/constructs/ConstructOutlet";
import { AnalyticConstruct } from "../../../analysis/predicates";
import { CompiledTemporaryDeallocator } from "../TemporaryDeallocator";
import { AssignmentExpressionASTNode } from "../../../ast/ast_expressions";
import { SimpleRuntimeExpression } from "./SimpleRuntimeExpression";
import { OperatorOverloadExpression } from "./OperatorOverloadExpression";
export declare class AssignmentExpression extends Expression<AssignmentExpressionASTNode> {
    readonly construct_type = "assignment_expression";
    readonly type?: AtomicType;
    readonly valueCategory = "lvalue";
    readonly lhs: Expression;
    readonly rhs: Expression;
    private constructor();
    static createFromAST(ast: AssignmentExpressionASTNode, context: ExpressionContext): AssignmentExpression | OperatorOverloadExpression;
    createDefaultOutlet(this: CompiledAssignmentExpression, element: JQuery, parent?: ConstructOutlet): AssignmentExpressionOutlet;
    describeEvalResult(depth: number): ConstructDescription;
    explain(sim: Simulation, rtConstruct: RuntimeConstruct): {
        message: string;
    };
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, ec: SemanticContext): boolean;
}
export interface TypedAssignmentExpression<T extends AtomicType = AtomicType> extends AssignmentExpression, t_TypedExpression {
    readonly type: T;
    readonly lhs: TypedExpression<T>;
}
export interface CompiledAssignmentExpression<T extends AtomicType = AtomicType> extends TypedAssignmentExpression<T>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly lhs: CompiledExpression<T, "lvalue">;
    readonly rhs: CompiledExpression<T, "prvalue">;
}
export declare class RuntimeAssignment<T extends AtomicType = AtomicType> extends SimpleRuntimeExpression<T, "lvalue", CompiledAssignmentExpression<T>> {
    readonly lhs: RuntimeExpression<T, "lvalue">;
    readonly rhs: RuntimeExpression<T, "prvalue">;
    constructor(model: CompiledAssignmentExpression<T>, parent: RuntimeConstruct);
    protected operate(): void;
}