/// <reference types="jquery" />
/// <reference types="bootstrap" />
import { AnalyticConstruct } from "../../../analysis/predicates";
import { CommaASTNode, TernaryASTNode } from "../../../ast/ast_expressions";
import { CommaExpressionOutlet, TernaryExpressionOutlet } from "../../../view/constructs/ExpressionOutlets";
import { ConstructOutlet } from "../../../view/constructs/ConstructOutlet";
import { ConstructDescription, ExpressionContext, SemanticContext } from "../../compilation/contexts";
import { Bool, ExpressionType } from "../../compilation/types";
import { RuntimeConstruct, SuccessfullyCompiled } from "../CPPConstruct";
import { CompiledTemporaryDeallocator } from "../TemporaryDeallocator";
import { CompiledExpression, Expression, TypedExpression, t_TypedExpression, ValueCategory } from "./Expression";
import { RuntimeExpression } from "./RuntimeExpression";
import { SimpleRuntimeExpression } from "./SimpleRuntimeExpression";
export declare class CommaExpression extends Expression<CommaASTNode> {
    readonly construct_type = "comma_expression";
    readonly type?: ExpressionType;
    readonly valueCategory?: ValueCategory;
    readonly left: Expression;
    readonly right: Expression;
    constructor(context: ExpressionContext, ast: CommaASTNode, left: Expression, right: Expression);
    static createFromAST(ast: CommaASTNode, context: ExpressionContext): CommaExpression;
    createDefaultOutlet(this: CompiledCommaExpression, element: JQuery, parent?: ConstructOutlet): CommaExpressionOutlet;
    describeEvalResult(depth: number): ConstructDescription;
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, ec: SemanticContext): boolean;
}
export interface TypedCommaExpression<T extends ExpressionType = ExpressionType, V extends ValueCategory = ValueCategory> extends CommaExpression, t_TypedExpression {
    readonly type: T;
    readonly valueCategory: V;
    readonly right: TypedExpression<T, V>;
}
export interface CompiledCommaExpression<T extends ExpressionType = ExpressionType, V extends ValueCategory = ValueCategory> extends TypedCommaExpression<T, V>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly left: CompiledExpression;
    readonly right: CompiledExpression<T, V>;
}
export declare class RuntimeComma<T extends ExpressionType = ExpressionType, V extends ValueCategory = ValueCategory> extends SimpleRuntimeExpression<T, V, CompiledCommaExpression<T, V>> {
    left: RuntimeExpression;
    right: RuntimeExpression<T, V>;
    constructor(model: CompiledCommaExpression<T, V>, parent: RuntimeConstruct);
    protected operate(): void;
}
export declare class TernaryExpression extends Expression<TernaryASTNode> {
    readonly construct_type = "ternary_expression";
    readonly type?: ExpressionType;
    readonly valueCategory?: ValueCategory;
    readonly condition: Expression;
    readonly then: Expression;
    readonly otherwise: Expression;
    constructor(context: ExpressionContext, ast: TernaryASTNode, condition: Expression, then: Expression, otherwise: Expression);
    static createFromAST(ast: TernaryASTNode, context: ExpressionContext): TernaryExpression;
    private compileCondition;
    private compileConsequences;
    createDefaultOutlet(this: CompiledTernaryExpression, element: JQuery, parent?: ConstructOutlet): TernaryExpressionOutlet;
    describeEvalResult(depth: number): ConstructDescription;
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, ec: SemanticContext): boolean;
}
export interface TypedTernaryExpression<T extends ExpressionType = ExpressionType, V extends ValueCategory = ValueCategory> extends TernaryExpression, t_TypedExpression {
    readonly type: T;
    readonly valueCategory: V;
    readonly then: TypedExpression<T, V>;
    readonly otherwise: TypedExpression<T, V>;
}
export interface CompiledTernaryExpression<T extends ExpressionType = ExpressionType, V extends ValueCategory = ValueCategory> extends TypedTernaryExpression<T, V>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly condition: CompiledExpression<Bool, "prvalue">;
    readonly then: CompiledExpression<T, V>;
    readonly otherwise: CompiledExpression<T, V>;
}
export declare class RuntimeTernary<T extends ExpressionType = ExpressionType, V extends ValueCategory = ValueCategory> extends RuntimeExpression<T, V, CompiledTernaryExpression<T, V>> {
    condition: RuntimeExpression<Bool, "prvalue">;
    then: RuntimeExpression<T, V>;
    otherwise: RuntimeExpression<T, V>;
    private index;
    constructor(model: CompiledTernaryExpression<T, V>, parent: RuntimeConstruct);
    protected upNextImpl(): void;
    protected stepForwardImpl(): void;
}