import { AbstractBinopExpr, AbstractExpr, ArkCastExpr, NormalBinaryOperator } from '../../../core/base/Expr';
import { Value } from '../../../core/base/Value';
import { ArrayType, ClassType, Type } from '../../../core/base/Type';
import { ArkMethod } from '../../../core/model/ArkMethod';
import { AbstractFieldRef } from '../../../core/base/Ref';
/**
 * delete[] expression in C++
 *  1. c++: delete[] a / delete[] a.b / delete[] a->b
 */
export declare class ArkCxxDeleteArrayExpr extends AbstractExpr {
    private field;
    constructor(field: AbstractFieldRef | Value);
    getField(): AbstractFieldRef | Value;
    setField(newField: AbstractFieldRef | Value): void;
    getType(): Type;
    getUses(): Value[];
    toString(): string;
}
export declare class ArkCxxNewArrayExpr extends AbstractExpr {
    private baseType;
    private size;
    private elementsNumber;
    private fromLiteral;
    constructor(baseType: Type, size: Value, fromLiteral?: boolean, elementsNumber?: number);
    getElementsNumber(): number;
    setElementsNumber(elementsNumber: number): void;
    getSize(): Value;
    setSize(newSize: Value): void;
    getType(): ArrayType;
    getBaseType(): Type;
    setBaseType(newType: Type): void;
    isFromLiteral(): boolean;
    inferType(arkMethod: ArkMethod): ArkCxxNewArrayExpr;
    getUses(): Value[];
    toString(): string;
}
export declare class ArkCxxInitArrayExpr extends AbstractExpr {
    private op;
    constructor(op: Value);
    getOp(): Value;
    setOp(newOp: Value): void;
    getUses(): Value[];
    getType(): Type;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare enum Operator {
    sizeof = "sizeof",
    alignof = "alignof",
    Unknown = "Unknown"
}
export declare class ArkCxxUnaryExpr extends AbstractExpr {
    private operator;
    private op;
    constructor(operator: Operator, op: Value | Type);
    getOp(): Value | Type;
    setOp(newOp: Value | Type): void;
    getOperator(): string;
    getUses(): Value[];
    getOpType(): Type;
    getType(): Type;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare class ArkCxxCastExpr extends ArkCastExpr {
    private cxxCastType;
    constructor(op: Value, type: Type, cxxCastType: string);
    getCxxCastType(): string;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare class ArkArrayTypeTraitExpr extends AbstractExpr {
    private op;
    private dimensionSizes;
    constructor(dimensionSizes: number[] | undefined, op: Value | null);
    getOp(): Value | null;
    setOp(newOp: Value): void;
    getUses(): Value[];
    getDimensionOrder(): number[];
    setDimensionOrder(dimensionOrder: number[]): void;
    getOpType(): Type | null;
    getType(): Type;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare class ArkTypeIdExpr extends AbstractExpr {
    private op;
    constructor(op: Value);
    getOp(): Value;
    setOp(newOp: Value): void;
    getUses(): Value[];
    getType(): Type;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare class ArkNoExpectExpr extends AbstractExpr {
    private op;
    constructor(op: Value);
    getOp(): Value;
    setOp(newOp: Value): void;
    getUses(): Value[];
    getOpType(): Type;
    getType(): Type;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare class ArkCxxFolderExpr extends AbstractExpr {
    private arg;
    private op;
    constructor(arg: Value, op: string);
    getArg(): Value;
    setArg(newArg: Value): void;
    getUses(): Value[];
    getType(): Type;
    getOp(): string;
    toString(): string;
    inferType(arkMethod: ArkMethod): AbstractExpr;
}
export declare class ArkCxxNormalBinOpExpr extends AbstractBinopExpr {
    constructor(op1: Value, op2: Value, operator: NormalBinaryOperator);
    getType(): Type;
    setCxxType(type: Type): void;
}
export declare class ArkAllocExpr extends AbstractExpr {
    private classType;
    constructor(classType: ClassType);
    getClassType(): ClassType;
    getUses(): Value[];
    getType(): Type;
    toString(): string;
    /**
     *Inference type method
     *@ param arkMethod - Ark method object, the context used for type inference
     *@ returns the ArkNewExpr instance of the current object
     */
    inferType(arkMethod: ArkMethod): ArkAllocExpr;
    private constructorSignature;
}
/**
 * Aggregate expression to represent such cases :
 *     struct Point q = (struct Point){.x = 5, .y = 8, .name = 'c'};
 *     int* arr = (int[5]){1, 2, 3, 4, 5};
 *     the right value is {},its kind is CompoundLiteralExpr or InitListExpr
 */
export declare class ArkAggregateExpr extends AbstractExpr {
    private type;
    private elements;
    constructor(elements: Value[], type: Type);
    getElements(): Value[];
    setType(type: Type): void;
    getUses(): Value[];
    getType(): Type;
    inferType(arkMethod: ArkMethod): ArkAggregateExpr;
    toString(): string;
}
/**
 * ArkDesignatedInitExpr is used to represent designated initializers in aggregate initialization expressions.
 * It consists of an initializer value and a designator, which specifies the field or element to be initialized.
 * For example:
 *     struct Point q = (struct Point){.x = 5, .y = 8, .name = 'c'};
 *     its kind is DesignatedInitExpr
 */
export declare class ArkDesignatedInitExpr extends AbstractExpr {
    private init;
    private designator;
    constructor(init: Value, designator: Value);
    getInit(): Value;
    getDesignator(): Value;
    inferType(arkMethod: ArkMethod): ArkDesignatedInitExpr;
    getUses(): Value[];
    getType(): Type;
    toString(): string;
}
//# sourceMappingURL=Expr.d.ts.map