import { Type, NumberType, GenericType } from '../../../core/base/Type';
import { Value } from '../../../core/base/Value';
/** Enum representing the bitWidth of Cxx types. */
export declare enum CxxTypeBitWidth {
    EIGHT_BITS = 8,
    SIXTEEN_BITS = 16,
    THIRTY_TWO_BITS = 32,
    SIXTY_FOUR_BITS = 64,
    UNKNOWN = -1
}
/** Enum representing the signedness attribute of Cxx types. */
export declare enum CxxTypeSigned {
    UNSIGNED = 0,
    SIGNED = 1,
    UNKNOWN = -1
}
/** Enumerate the standard library types of Cxx */
export declare enum CxxStdTypeName {
    CHAR = 1,
    SIGNED_CHAR = 2,
    UNSIGNED_CHAR = 3,
    WCHAR_T = 4,
    CHAR16_T = 5,
    CHAR32_T = 6,
    SHORT = 7,
    UNSIGNED_SHORT = 8,
    INT = 9,
    UNSIGNED_INT = 10,
    LONG = 11,
    UNSIGNED_LONG = 12,
    LONG_LONG = 13,
    UNSIGNED_LONG_LONG = 14,
    UINT8_T = 15,
    UINT16_T = 16,
    UINT32_T = 17,
    UINT64_T = 18,
    INT8_T = 19,
    INT16_T = 20,
    INT32_T = 21,
    INT64_T = 22,
    SIZE_T = 23,
    INTPTR_T = 24,
    UINTPTR_T = 25
}
/**
 * integral type in cxx, for example int, short, long and so on.
 * @category core/base/type
 */
export declare class CxxIntegralType extends NumberType {
    protected readonly signType: CxxTypeSigned;
    protected readonly bitWidth: CxxTypeBitWidth;
    protected readonly oriTypeName?: CxxStdTypeName;
    protected constructor(signType: CxxTypeSigned, bitWidth: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName);
    static getInstance(signType?: CxxTypeSigned, size?: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxIntegralType;
    getSignType(): CxxTypeSigned;
    getBitWidth(): CxxTypeBitWidth;
    getOriTypeName(): CxxStdTypeName | undefined;
}
/**
 * int type in cxx
 * @category core/base/type
 */
export declare class CxxIntType extends CxxIntegralType {
    static getInstance(signType: CxxTypeSigned, bitWidth: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxIntType;
    getTypeString(): string;
}
/**
 * short type in cxx
 * @category core/base/type
 */
export declare class CxxShortType extends CxxIntegralType {
    static getInstance(signType: CxxTypeSigned, bitWidth: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxShortType;
    getTypeString(): string;
}
/**
 * long type in cxx
 * @category core/base/type
 */
export declare class CxxLongType extends CxxIntegralType {
    static getInstance(signType: CxxTypeSigned, bitWidth: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxLongType;
    getTypeString(): string;
}
/**
 * long long type in cxx
 * @category core/base/type
 */
export declare class CxxLongLongType extends CxxIntegralType {
    static getInstance(signType: CxxTypeSigned, bitWidth: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxLongLongType;
    getTypeString(): string;
}
/**
 * size_t type in cxx
 * @category core/base/type
 */
export declare class CxxSizeTType extends CxxIntegralType {
    static getInstance(signType: CxxTypeSigned, bitWidth: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxSizeTType;
    getTypeString(): string;
}
/**
 * floating-point types in cxx, for example float, double and so on.
 * @category core/base/type
 */
export declare class CxxFloatingPointType extends NumberType {
    static getInstance(): CxxFloatingPointType;
    getBitWith(): CxxTypeBitWidth;
}
/**
 * float type in cxx
 * @category core/base/type
 */
export declare class CxxFloatType extends CxxFloatingPointType {
    static getInstance(): CxxFloatType;
    getTypeString(): string;
    getBitWidth(): CxxTypeBitWidth;
}
/**
 * double type in cxx
 * @category core/base/type
 */
export declare class CxxDoubleType extends CxxFloatingPointType {
    static getInstance(): CxxDoubleType;
    getTypeString(): string;
    getBitWidth(): CxxTypeBitWidth;
}
/**
 * long double type in cxx
 * @category core/base/type
 */
export declare class CxxLongDoubleType extends CxxFloatingPointType {
    static getInstance(): CxxLongDoubleType;
    getTypeString(): string;
    getBitWidth(): CxxTypeBitWidth;
}
/**
 * char type in cxx
 * @category core/base/type
 */
export declare class CxxCharType extends Type {
    private readonly signType;
    private readonly bitWidth;
    private readonly oriTypeName?;
    private constructor();
    static getInstance(signType?: CxxTypeSigned, size?: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxCharType;
    getSignType(): CxxTypeSigned;
    getBitWidth(): CxxTypeBitWidth;
    getOriTypeName(): CxxStdTypeName | undefined;
    getTypeString(): string;
}
/**
 * wchar_t type in cxx
 * @category core/base/type
 */
export declare class CxxWcharType extends CxxIntegralType {
    static getInstance(signType?: CxxTypeSigned, size?: CxxTypeBitWidth, oriTypeName?: CxxStdTypeName): CxxWcharType;
    getTypeString(): string;
}
/**
 *PointerType class represents pointer type, inherited from Type base class
 *Pointer types used to represent C language style, such as int *, char * *, etc
 */
export declare class PointerType extends Type {
    private baseType;
    private level;
    private isConstPointer;
    private isPointerToConst;
    private isVolatilePointer;
    private isPointerToVolatileType;
    constructor(baseType: Type, level: number);
    getBaseType(): Type;
    setBaseType(newBaseType: Type): void;
    getLevel(): number;
    getTypeString(): string;
    getIsConstPointer(): boolean;
    setIsConstPointer(isConstPointer: boolean): void;
    getIsPointerToConst(): boolean;
    setIsPointerToConst(isPointerToConst: boolean): void;
    getIsVolatilePointer(): boolean;
    setIsVolatilePointer(isVolatilePointer: boolean): void;
    getIsPointerToVolatileType(): boolean;
    setIsPointerToVolatileType(isPointerToVolatileType: boolean): void;
}
export declare enum SmartPointerCategory {
    UNKNOWN = -1,
    UNIQUE_PTR = 0,
    SHARED_PTR = 1,
    WEAK_PTR = 2
}
export declare class SmartPointerType extends PointerType {
    private category;
    constructor(baseType: Type, level: number, source: string);
    getCategory(): SmartPointerCategory;
    setCategory(category: SmartPointerCategory): void;
    getTypeString(): string;
}
/**
 *Reference category enumeration, used to distinguish different types of references
 *LVALUE_REF: Left value reference, the reference type of address can be obtained
 *RVALUE_REF: Right value reference, used to bind the reference type of temporary object
 *UNIVERSAL_REF: universal reference, which can bind reference types of left or right values
 */
export declare enum ReferCategory {
    LVALUE_REF = 0,
    RVALUE_REF = 1,
    UNIVERSAL_REF = 2
}
/**
 *The ReferenceType class represents the reference type, inherited from the Type base class
 *Used to represent the type of left value reference (&) and right value reference (&&) in C++
 */
export declare class ReferenceType extends Type {
    private baseType;
    private category;
    private sourceValue?;
    constructor(bassType: Type, category: ReferCategory, sourceValue?: Value);
    getBaseType(): Type;
    setBaseType(newBaseType: Type): void;
    getCategory(): ReferCategory;
    setSourceValue(sourceValue: Value): void;
    getSourceValue(): Value | undefined;
    getTypeString(): string;
}
/**
 *The Thread class inherits from the Type class and represents a thread type
 *This class provides the basic implementation of thread types
 */
export declare class Thread extends Type {
    constructor();
    getTypeString(): string;
}
export declare class TypeInfo extends Type {
    private name;
    private type;
    constructor(name: string, type: Type);
    getName(): string;
    getType(): Type;
    getTypeString(): string;
}
export declare class CxxNonType extends GenericType {
    constructor(name: string, defaultType?: Type, isAutoType?: boolean);
}
export declare class CxxArrayType extends Type {
    private baseType;
    private dimension;
    private dimensionSizes;
    constructor(baseType: Type, dimension: number, dimensionSizes?: number[]);
    /**
     * Returns the base type of this array, such as `Any`, `Unknown`, `TypeParameter`, etc.
     * @returns The base type of array.
     */
    getBaseType(): Type;
    setBaseType(newType: Type): void;
    getDimension(): number;
    getDimensionSizes(): number[];
    setDimensionSizes(sizes: number[]): void;
    getDimensionSize(index: number): number;
    getTypeString(): string;
}
export declare class AutoType extends Type {
    private static readonly INSTANCE;
    static getInstance(): AutoType;
    private constructor();
    getTypeString(): string;
}
//# sourceMappingURL=Type.d.ts.map