export declare const enum TypeKind {
    Any = 0,
    Array = 1,
    BigInt = 2,
    BigIntLiteral = 3,
    Boolean = 4,
    BooleanLiteral = 5,
    Enum = 6,
    EnumLiteral = 7,
    Intersection = 8,
    Mapped = 9,
    Never = 10,
    Null = 11,
    Number = 12,
    NumberLiteral = 13,
    Object = 14,
    String = 15,
    StringLiteral = 16,
    Symbol = 17,
    TemplateLiteral = 18,
    Tuple = 19,
    Undefined = 20,
    Union = 21,
    Unknown = 22,
    Void = 23
}
export declare const enum ObjectKind {
    None = 0,
    Class = 1,
    Interface = 2,
    Reference = 4,
    Tuple = 8,
    Anonymous = 16,
    Mapped = 32,
    Instantiated = 64,
    ObjectLiteral = 128,
    EvolvingArray = 256,
    ObjectLiteralPatternWithComputedProperties = 512,
    ReverseMapped = 1024,
    JsxAttributes = 2048,
    JSLiteral = 4096,
    FreshLiteral = 8192,
    ArrayLiteral = 16384,
    /** @internal */
    PrimitiveUnion = 32768,
    /** @internal */
    ContainsWideningType = 65536,
    /** @internal */
    ContainsObjectOrArrayLiteral = 131072,
    /** @internal */
    NonInferrableType = 262144,
    /** @internal */
    CouldContainTypeVariablesComputed = 524288,
    /** @internal */
    CouldContainTypeVariables = 1048576,
    ClassOrInterface = 3,
    /** @internal */
    RequiresWidening = 196608,
    /** @internal */
    PropagatingFlags = 458752,
    /** @internal */
    InstantiatedMapped = 96,
    /** @internal */
    ObjectTypeKindMask = 1343,
    ContainsSpread = 2097152,
    ObjectRestType = 4194304,
    InstantiationExpressionType = 8388608,
    /** @internal */
    IsClassInstanceClone = 16777216,
    /** @internal */
    IdenticalBaseTypeCalculated = 33554432,
    /** @internal */
    IdenticalBaseTypeExists = 67108864,
    /** @internal */
    IsGenericTypeComputed = 2097152,
    /** @internal */
    IsGenericObjectType = 4194304,
    /** @internal */
    IsGenericIndexType = 8388608,
    /** @internal */
    IsGenericType = 12582912,
    /** @internal */
    ContainsIntersections = 16777216,
    /** @internal */
    IsUnknownLikeUnionComputed = 33554432,
    /** @internal */
    IsUnknownLikeUnion = 67108864,
    /** @internal */
    /** @internal */
    IsNeverIntersectionComputed = 16777216,
    /** @internal */
    IsNeverIntersection = 33554432
}
interface BaseType<T extends TypeKind> {
    kind: T;
    toString(): string;
}
export interface AnyType extends BaseType<TypeKind.Any> {
}
export interface ArrayType extends BaseType<TypeKind.Array> {
    type?: Type;
}
export interface BigIntType extends BaseType<TypeKind.BigInt> {
}
export interface BigIntLiteralType extends BaseType<TypeKind.BigIntLiteral> {
    value?: bigint;
}
export interface BooleanType extends BaseType<TypeKind.Boolean> {
}
export interface BooleanLiteralType extends BaseType<TypeKind.BooleanLiteral> {
    value?: boolean;
}
export interface EnumType extends BaseType<TypeKind.Enum> {
}
export interface EnumLiteralType extends BaseType<TypeKind.Enum> {
    value?: unknown;
}
export interface IntersectionType extends BaseType<TypeKind.Intersection> {
    types?: Type[];
}
export interface NeverType extends BaseType<TypeKind.Never> {
}
export interface NullType extends BaseType<TypeKind.Null> {
}
export interface NumberType extends BaseType<TypeKind.Number> {
}
export interface NumberLiteralType extends BaseType<TypeKind.NumberLiteral> {
    value?: number;
}
export type ObjectType = AnonymousObjectType | MappedObjectType | BaseObjectType<Exclude<ObjectKind, ObjectKind.Anonymous | ObjectKind.Mapped>>;
export interface StringType extends BaseType<TypeKind.String> {
}
export interface StringLiteralType extends BaseType<TypeKind.StringLiteral> {
    value?: string;
}
export interface SymbolType extends BaseType<TypeKind.Symbol> {
    unique?: boolean;
}
export interface TemplateLiteralType extends BaseType<TypeKind.TemplateLiteral> {
    template?: (string | Type)[];
}
export interface TupleType extends BaseType<TypeKind.Tuple> {
    types?: Type[];
}
export interface UndefinedType extends BaseType<TypeKind.Undefined> {
}
export interface UnionType extends BaseType<TypeKind.Union> {
    types?: Type[];
}
export interface UnknownType extends BaseType<TypeKind.Unknown> {
}
export interface VoidType extends BaseType<TypeKind.Void> {
}
export interface BaseObjectType<T extends ObjectKind = ObjectKind.Anonymous> extends BaseType<TypeKind.Object> {
    objectKind: T;
}
export interface AnonymousObjectType extends BaseObjectType<ObjectKind.Anonymous> {
    indexes?: Array<{
        keyType: Type;
        type: Type;
    }>;
    properties?: Record<string, Type>;
}
export interface MappedObjectType extends BaseObjectType<ObjectKind.Mapped> {
    properties?: string[];
    templateType?: Type;
}
export type Type = AnyType | ArrayType | UnknownType | StringType | NumberType | BooleanType | EnumType | BigIntType | StringLiteralType | NumberLiteralType | BooleanLiteralType | EnumLiteralType | BigIntLiteralType | SymbolType | VoidType | UndefinedType | NullType | NeverType | ObjectType | UnionType | IntersectionType | TupleType | TemplateLiteralType;
declare const _default: {
    array: (type?: Type) => ArrayType;
    bigInt: () => BigIntType;
    bigIntLiteral: (value?: bigint) => BigIntLiteralType;
    boolean: () => BooleanType;
    booleanLiteral: (value?: boolean) => BooleanLiteralType;
    intersection: (types?: Type[]) => IntersectionType;
    mappedType: (options?: Pick<MappedObjectType, 'properties' | 'templateType'>) => MappedObjectType;
    never: () => NeverType;
    null: () => NullType;
    number: () => NumberType;
    numberLiteral: (value?: number) => NumberLiteralType;
    anonymousObject: (options?: Pick<AnonymousObjectType, 'indexes' | 'properties'>) => AnonymousObjectType;
    object: (object?: ObjectType) => ObjectType;
    string: () => StringType;
    stringLiteral: (value?: string) => StringLiteralType;
    symbol: (unique?: boolean) => SymbolType;
    templateLiteral: (template?: (string | Type)[]) => TemplateLiteralType;
    tuple: (types?: Type[]) => TupleType;
    undefined: () => UndefinedType;
    union: (types?: Type[]) => UnionType;
    unknown: () => UnknownType;
    void: () => VoidType;
};
export default _default;
//# sourceMappingURL=types.d.ts.map