/// <reference types="jquery" />
/// <reference types="bootstrap" />
import { CompleteObjectType, AtomicType, IntegralType, PointerType, BoundedArrayType, Bool, ArithmeticType, Int, Float, Double, ArrayElemType, FloatingPointType, CompleteClassType, ExpressionType } from "../../compilation/types";
import { ConstructDescription, SemanticContext } from "../../compilation/contexts";
import { SuccessfullyCompiled, RuntimeConstruct } from "../CPPConstruct";
import { Value } from "../../runtime/Value";
import { VCResultTypes, ValueCategory, Expression, CompiledExpression, TypedExpression, SpecificTypedExpression, t_TypedExpression } from "./Expression";
import { RuntimeExpression } from "./RuntimeExpression";
import { LValueToRValueOutlet, ArrayToPointerOutlet, TypeConversionOutlet, QualificationConversionOutlet, StreamToBoolOutlet } from "../../../view/constructs/TypeConversionOutlets";
import { ConstructOutlet } from "../../../view/constructs/ConstructOutlet";
import { AnalyticConstruct } from "../../../analysis/predicates";
import { CompiledTemporaryDeallocator } from "../TemporaryDeallocator";
import { SimpleRuntimeExpression } from "./SimpleRuntimeExpression";
import { CompiledNullptrExpression } from "./NullptrExpression";
import { CompiledNumericLiteralExpression } from "./NumericLiteralExpression";
export declare abstract class ImplicitConversion<FromType extends CompleteObjectType = CompleteObjectType, FromVC extends ValueCategory = ValueCategory, ToType extends CompleteObjectType = CompleteObjectType, ToVC extends ValueCategory = ValueCategory> extends Expression {
    readonly construct_type = "ImplicitConversion";
    readonly from: TypedExpression<FromType, FromVC>;
    readonly type: ToType;
    readonly valueCategory: ToVC;
    readonly conversionLength: number;
    constructor(from: TypedExpression<FromType, FromVC>, toType: ToType, valueCategory: ToVC);
    createRuntimeExpression<FromType extends CompleteObjectType, FromVC extends ValueCategory, ToType extends CompleteObjectType, ToVC extends ValueCategory>(this: CompiledImplicitConversion<FromType, FromVC, ToType, ToVC>, parent: RuntimeConstruct): RuntimeImplicitConversion<FromType, FromVC, ToType, ToVC>;
    createRuntimeExpression<T extends ExpressionType, V extends ValueCategory>(this: CompiledExpression<T, V>, parent: RuntimeConstruct): never;
    abstract operate(fromEvalResult: VCResultTypes<FromType, FromVC>): VCResultTypes<ToType, ToVC>;
    describeEvalResult(depth: number): ConstructDescription;
}
export interface TypedImplicitConversion<FromType extends CompleteObjectType = CompleteObjectType, FromVC extends ValueCategory = ValueCategory, ToType extends CompleteObjectType = CompleteObjectType, ToVC extends ValueCategory = ValueCategory> extends ImplicitConversion<FromType, FromVC, ToType, ToVC>, t_TypedExpression {
}
export interface CompiledImplicitConversion<FromType extends CompleteObjectType = CompleteObjectType, FromVC extends ValueCategory = ValueCategory, ToType extends CompleteObjectType = CompleteObjectType, ToVC extends ValueCategory = ValueCategory> extends TypedImplicitConversion<FromType, FromVC, ToType, ToVC>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: CompiledExpression<FromType, FromVC>;
}
export declare class RuntimeImplicitConversion<FromType extends CompleteObjectType = CompleteObjectType, FromVC extends ValueCategory = ValueCategory, ToType extends CompleteObjectType = CompleteObjectType, ToVC extends ValueCategory = ValueCategory> extends SimpleRuntimeExpression<ToType, ToVC, CompiledImplicitConversion<FromType, FromVC, ToType, ToVC>> {
    readonly from: RuntimeExpression<FromType, FromVC>;
    constructor(model: CompiledImplicitConversion<FromType, FromVC, ToType, ToVC>, parent: RuntimeConstruct);
    protected operate(): void;
}
export declare class LValueToRValueConversion<T extends AtomicType> extends ImplicitConversion<T, "lvalue", T, "prvalue"> {
    constructor(from: TypedExpression<T, "lvalue">);
    operate(fromEvalResult: VCResultTypes<T, "lvalue">): VCResultTypes<T, "prvalue">;
    createDefaultOutlet(this: CompiledLValueToRValueConversion, element: JQuery, parent?: ConstructOutlet): LValueToRValueOutlet;
}
export interface TypedLValueToRValueConversion<T extends AtomicType = AtomicType> extends LValueToRValueConversion<T>, t_TypedExpression {
}
export interface CompiledLValueToRValueConversion<T extends AtomicType = AtomicType> extends TypedLValueToRValueConversion<T>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: CompiledExpression<T, "lvalue">;
}
export declare class ArrayToPointerConversion<T extends BoundedArrayType> extends ImplicitConversion<T, "lvalue", PointerType, "prvalue"> {
    constructor(from: TypedExpression<T, "lvalue">);
    operate(fromEvalResult: VCResultTypes<BoundedArrayType, "lvalue">): Value<import("../../compilation/types").ArrayPointerType<ArrayElemType>>;
    createDefaultOutlet(this: CompiledArrayToPointerConversion, element: JQuery, parent?: ConstructOutlet): ArrayToPointerOutlet;
}
export interface TypedArrayToPointerConversion<T extends BoundedArrayType = BoundedArrayType> extends ArrayToPointerConversion<T>, t_TypedExpression {
}
export interface CompiledArrayToPointerConversion<T extends BoundedArrayType = BoundedArrayType> extends TypedArrayToPointerConversion<T>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: CompiledExpression<T, "lvalue">;
}
export declare class StreamToBoolConversion extends ImplicitConversion<CompleteClassType, "lvalue", Bool, "prvalue"> {
    constructor(from: TypedExpression<CompleteClassType, "lvalue">);
    operate(fromEvalResult: VCResultTypes<CompleteClassType, "lvalue">): Value<Bool>;
    createDefaultOutlet(this: CompiledStreamToBoolConversion, element: JQuery, parent?: ConstructOutlet): StreamToBoolOutlet;
}
export interface TypedStreamToBoolConversion extends StreamToBoolConversion, t_TypedExpression {
}
export interface CompiledStreamToBoolConversion extends TypedStreamToBoolConversion, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: CompiledExpression<CompleteClassType, "lvalue">;
}
/**
 * All type conversions ignore (top-level) cv-qualifications on the given destination
 * type. This is because type conversions only operate on prvalues of atomic type,
 * which cannot be cv-qualified. For convenience, the user may still specify a
 * cv-qualified type and the cv-unqualified version will be used instead.
 */
declare abstract class TypeConversion<FromType extends AtomicType, ToType extends AtomicType> extends ImplicitConversion<FromType, "prvalue", ToType, "prvalue"> {
    constructor(from: TypedExpression<FromType, "prvalue">, toType: ToType);
    createDefaultOutlet(this: CompiledTypeConversion, element: JQuery, parent?: ConstructOutlet): TypeConversionOutlet;
}
export interface TypedTypeConversion<FromType extends AtomicType = AtomicType, ToType extends AtomicType = AtomicType> extends TypeConversion<FromType, ToType>, t_TypedExpression {
}
export interface CompiledTypeConversion<FromType extends AtomicType = AtomicType, ToType extends AtomicType = AtomicType> extends TypedTypeConversion<FromType, ToType>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: CompiledExpression<FromType, "prvalue">;
}
declare abstract class NoOpTypeConversion<FromType extends AtomicType, ToType extends AtomicType> extends TypeConversion<FromType, ToType> {
    constructor(from: TypedExpression<FromType, "prvalue">, toType: ToType);
    operate(fromEvalResult: VCResultTypes<FromType, "prvalue">): VCResultTypes<ToType, "prvalue">;
}
export declare type IntegerLiteralZero = CompiledNumericLiteralExpression<Int> & {
    value: Value<Int> & {
        rawValue: 0;
    };
} | CompiledNullptrExpression;
export declare class NullPointerConversion<P extends PointerType> extends NoOpTypeConversion<Int, P> {
    readonly from: IntegerLiteralZero;
    constructor(from: IntegerLiteralZero, toType: P);
}
export interface TypedNullPointerConversion<P extends PointerType> extends NullPointerConversion<P>, t_TypedExpression {
}
export interface CompiledNullPointerConversion<P extends PointerType> extends TypedNullPointerConversion<P>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: IntegerLiteralZero;
}
export declare class PointerConversion<FromType extends PointerType, ToType extends PointerType> extends NoOpTypeConversion<FromType, ToType> {
}
export interface TypedPointerConversion<FromType extends PointerType, ToType extends PointerType> extends TypedTypeConversion<FromType, ToType> {
}
export interface CompiledPointerConversion<FromType extends PointerType, ToType extends PointerType> extends CompiledTypeConversion<FromType, ToType> {
}
export declare abstract class ToBooleanConversion<T extends AtomicType = AtomicType> extends TypeConversion<T, Bool> {
    constructor(from: TypedExpression<T, "prvalue">);
    operate(fromEvalResult: VCResultTypes<T, "prvalue">): Value<Bool>;
}
export declare class PointerToBooleanConversion<T extends PointerType = PointerType> extends ToBooleanConversion<T> {
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, ec: SemanticContext): boolean;
}
export declare class FloatingToBooleanConversion<T extends FloatingPointType = FloatingPointType> extends ToBooleanConversion<T> {
}
export declare class IntegralToBooleanConversion<T extends IntegralType = IntegralType> extends ToBooleanConversion<T> {
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, ec: SemanticContext): boolean;
}
export declare class IntegralPromotion<FromType extends IntegralType, ToType extends IntegralType> extends NoOpTypeConversion<FromType, ToType> {
}
export declare class IntegralConversion<FromType extends IntegralType, ToType extends IntegralType> extends NoOpTypeConversion<FromType, ToType> {
}
export declare class FloatingPointPromotion extends NoOpTypeConversion<Float, Double> {
    constructor(from: TypedExpression<Float, "prvalue">);
}
export declare class FloatingPointConversion<FromType extends FloatingPointType, ToType extends FloatingPointType> extends NoOpTypeConversion<FromType, ToType> {
}
export declare class IntegralToFloatingConversion<FromType extends IntegralType, ToType extends FloatingPointType> extends NoOpTypeConversion<FromType, ToType> {
}
export declare class FloatingToIntegralConversion<T extends FloatingPointType> extends TypeConversion<T, IntegralType> {
    operate(fromEvalResult: VCResultTypes<T, "prvalue">): Value<Int>;
}
export declare class QualificationConversion<T extends AtomicType = AtomicType> extends ImplicitConversion<T, "prvalue", T, "prvalue"> {
    constructor(from: TypedExpression<T, "prvalue">, toType: T);
    createDefaultOutlet(this: CompiledQualificationConversion, element: JQuery, parent?: ConstructOutlet): QualificationConversionOutlet;
    operate(fromEvalResult: VCResultTypes<T, "prvalue">): VCResultTypes<T, "prvalue">;
}
export interface TypedQualificationConversion<T extends AtomicType = AtomicType> extends QualificationConversion<T>, t_TypedExpression {
}
export interface CompiledQualificationConversion<T extends AtomicType = AtomicType> extends TypedQualificationConversion<T>, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly from: CompiledExpression<T, "prvalue">;
}
export declare function convertToPRValue<T extends AtomicType>(from: SpecificTypedExpression<T>): TypedExpression<T, "prvalue">;
export declare function convertToPRValue<Elem_type extends ArrayElemType>(from: TypedExpression<BoundedArrayType<Elem_type>, "lvalue">): TypedExpression<PointerType<Elem_type>, "prvalue">;
export declare function convertToPRValue(from: SpecificTypedExpression<PointerType> | TypedExpression<BoundedArrayType, "lvalue">): TypedExpression<PointerType, "prvalue">;
export declare function convertToPRValue(from: SpecificTypedExpression<AtomicType> | TypedExpression<BoundedArrayType, "lvalue">): TypedExpression<AtomicType, "prvalue">;
export declare function convertToPRValue(from: TypedExpression): TypedExpression;
export declare function typeConversion(from: TypedExpression<PointerType, "prvalue">, toType: Bool): TypedExpression<Bool, "prvalue">;
export declare function typeConversion(from: TypedExpression<Double, "prvalue">, toType: Float): TypedExpression<Float, "prvalue">;
export declare function typeConversion(from: TypedExpression<IntegralType, "prvalue">, toType: IntegralType): TypedExpression<IntegralType, "prvalue">;
export declare function typeConversion(from: TypedExpression<FloatingPointType, "prvalue">, toType: IntegralType): TypedExpression<IntegralType, "prvalue">;
export declare function typeConversion(from: TypedExpression<IntegralType, "prvalue">, toType: FloatingPointType): TypedExpression<FloatingPointType, "prvalue">;
export declare function typeConversion(from: TypedExpression<FloatingPointType, "prvalue">, toType: FloatingPointType): TypedExpression<FloatingPointType, "prvalue">;
export declare function typeConversion<SimilarType extends AtomicType>(from: TypedExpression<SimilarType, "prvalue">, toType: SimilarType): TypedExpression<SimilarType, "prvalue">;
export declare function typeConversion<FromType extends AtomicType, ToType extends AtomicType>(from: TypedExpression<FromType, "prvalue">, toType: ToType): TypedExpression<FromType, "prvalue"> | TypedExpression<ToType, "prvalue">;
export declare function qualificationConversion(from: TypedExpression<AtomicType, "prvalue">, toType: AtomicType): TypedExpression<AtomicType, "prvalue">;
export interface StandardConversionOptions {
    readonly suppressLTR?: true;
}
/**
 * Attempts to generate a standard conversion sequence of the given expression to the given
 * destination type.
 * @param from The original expression
 * @param toType The destination type
 * @param options
 */
export declare function standardConversion(from: TypedExpression, toType: ExpressionType, options?: StandardConversionOptions): TypedExpression<ExpressionType, ValueCategory>;
export declare function integralPromotion(expr: TypedExpression<IntegralType, "prvalue">): TypedExpression<Int, "prvalue">;
export declare function isIntegerLiteralZero(from: Expression): from is IntegerLiteralZero;
export declare function isConvertibleToPointer(from: Expression): from is SpecificTypedExpression<PointerType> | TypedExpression<BoundedArrayType, "lvalue"> | IntegerLiteralZero;
export declare function isConvertible(from: TypedExpression, toType: ExpressionType, options?: StandardConversionOptions): boolean;
export declare function usualArithmeticConversions(leftOrig: SpecificTypedExpression<ArithmeticType>, rightOrig: SpecificTypedExpression<ArithmeticType>): TypedExpression<ArithmeticType, "prvalue">[];
export {};