import ts from "typescript";
import { FileExports } from "./ExportHandler";
export interface Module {
    name: string;
    modules: Map<string, Module>;
    classes: ClassDecl[];
    functions: FunctionDecl[];
    interfaces: InterfaceDecl[];
    types: TypeDecl[];
    enums: EnumDecl[];
    constants: ConstantDecl[];
    repository?: string;
    isGlobal?: boolean;
    isNamespace?: boolean;
    exports: Record<string, FileExports>;
    path: Array<string>;
    ref: ReferenceType;
    jsDoc?: Array<JSDocData>;
}
export interface JSDocTag {
    name: string;
    comment?: string;
    arg?: string;
    type?: Type;
}
export interface JSDocData {
    tags: Array<JSDocTag>;
    comment?: string;
}
export interface Loc {
    pos: ts.LineAndCharacter;
    sourceFile?: string;
    filename?: string;
}
export interface Node {
    name: string;
    loc: Loc;
    jsDoc?: Array<JSDocData>;
    id?: number;
    isCached?: boolean;
}
export declare type NamelessNode = Omit<Node, "name">;
export declare type LoclessNode = Omit<Node, "loc" | "name">;
export declare type NodeWithManyLOC = {
    name: string;
    jsDoc?: Array<JSDocData>;
    isExported?: boolean;
    loc: Array<Loc>;
    id?: number;
    isCached?: boolean;
};
export declare function createModule(name: string, path: Array<string>, isGlobal?: boolean, repository?: string, isNamespace?: boolean): Module;
export declare const enum TypeKinds {
    REFERENCE = 0,
    ARROW_FUNCTION = 1,
    OBJECT_LITERAL = 2,
    TUPLE = 3,
    UNION = 4,
    UNIQUE_OPERATOR = 5,
    READONLY_OPERATOR = 6,
    KEYOF_OPERATOR = 7,
    UNKNOWN = 8,
    STRINGIFIED_UNKNOWN = 9,
    ARRAY_TYPE = 10,
    INTERSECTION = 11,
    NUMBER = 12,
    STRING = 13,
    BOOLEAN = 14,
    VOID = 15,
    TRUE = 16,
    FALSE = 17,
    UNDEFINED = 18,
    NULL = 19,
    ANY = 20,
    NUMBER_LITERAL = 21,
    STRING_LITERAL = 22,
    MAPPED_TYPE = 23,
    CONDITIONAL_TYPE = 24,
    TEMPLATE_LITERAL = 25,
    INDEX_ACCESS = 26,
    TYPEOF_OPERATOR = 27,
    SYMBOL = 28,
    BIGINT = 29,
    TYPE_PREDICATE = 30,
    THIS = 31,
    NEVER = 32,
    OBJECT = 33,
    INFER_TYPE = 34,
    REGEX_LITERAL = 35,
    CONSTRUCTOR_TYPE = 36
}
export declare const enum TypeReferenceKinds {
    CLASS = 0,
    INTERFACE = 1,
    ENUM = 2,
    FUNCTION = 3,
    CONSTANT = 4,
    TYPE_ALIAS = 5,
    TYPE_PARAMETER = 6,
    UNKNOWN = 7,
    STRINGIFIED_UNKNOWN = 8,
    ENUM_MEMBER = 9,
    NAMESPACE_OR_MODULE = 10,
    EXTERNAL = 11,
    INTERNAL = 12
}
export declare const enum DeclarationTypes {
    CLASS = 0,
    INTERFACE = 1,
    ENUM = 2,
    FUNCTION = 3,
    CONSTANT = 4,
    TYPE_ALIAS = 5
}
export declare function createRefFromDecl(decl: Declaration | Module, module: Module): Reference;
export interface ReferenceType {
    name: string;
    displayName?: string;
    path?: Array<string>;
    link?: string;
    id?: number;
    kind: TypeReferenceKinds;
}
export interface BaseType {
    kind: TypeKinds;
}
export interface Reference extends BaseType {
    type: ReferenceType;
    typeArguments?: Array<Type>;
    kind: TypeKinds.REFERENCE;
}
export declare type Type = Reference | Literal | ArrowFunction | ObjectLiteral | UnionOrIntersection | TypeOperator | Tuple | ArrayType | MappedType | ConditionalType | TemplateLiteralType | IndexAccessedType | TypePredicateType | InferType | ConstructorType | StringifiedUnknown;
export interface StringifiedUnknown extends BaseType {
    name: string;
    kind: TypeKinds.STRINGIFIED_UNKNOWN;
}
export interface Literal extends BaseType {
    name: string;
    kind: TypeKinds.NUMBER_LITERAL | TypeKinds.STRING_LITERAL | TypeKinds.BOOLEAN | TypeKinds.REGEX_LITERAL;
}
export interface TypeParameter {
    name: string;
    default?: Type;
    constraint?: Type;
}
export interface ClassMember extends Node {
    isPublic?: boolean;
    isPrivate?: boolean;
    isStatic?: boolean;
    isProtected?: boolean;
    isAbstract?: boolean;
}
export interface Property {
    name: string | Type;
    rawName: string;
    type?: Type;
    isReadonly?: boolean;
    isOptional?: boolean;
    initializer?: Type;
    exclamation?: boolean;
}
export interface ClassProperty extends Omit<ClassMember, "name">, ObjectProperty {
    exclamation?: boolean;
    isReadonly?: boolean;
}
export interface FunctionParameter {
    name: string;
    type?: Type;
    rest?: boolean;
    isOptional?: boolean;
    defaultValue?: Type;
    jsDoc?: JSDocData;
    description?: string;
}
export interface FunctionSignature extends LoclessNode {
    parameters?: Array<FunctionParameter>;
    typeParameters?: Array<TypeParameter>;
    returnType?: Type;
}
export interface ClassMethod extends Omit<ClassMember, "name"> {
    signatures: Array<FunctionSignature>;
    isGetter?: boolean;
    isSetter?: boolean;
    isGenerator?: boolean;
    name: string | Type;
    rawName: string;
}
export declare type ClassConstructor = Omit<FunctionDecl, "name" | "kind">;
export interface ClassDecl extends Node {
    typeParameters?: Array<TypeParameter>;
    properties: Array<ClassProperty>;
    methods: Array<ClassMethod>;
    extends?: Reference;
    _constructor?: ClassConstructor;
    implements?: Array<Type>;
    isAbstract?: boolean;
    kind: DeclarationTypes.CLASS;
}
export interface FunctionDecl extends Node {
    signatures: Array<FunctionSignature>;
    isGenerator?: boolean;
    kind: DeclarationTypes.FUNCTION;
}
export declare type ConstructorType = FunctionSignature & BaseType;
export interface ArrowFunction extends BaseType {
    typeParameters?: Array<TypeParameter>;
    returnType?: Type;
    parameters?: Array<FunctionParameter>;
    kind: TypeKinds.ARROW_FUNCTION;
}
export interface IndexSignatureDeclaration {
    key?: Type;
    type: Type;
    isReadonly?: boolean;
}
export interface ObjectLiteral extends BaseType {
    properties: Array<ObjectProperty>;
    kind: TypeKinds.OBJECT_LITERAL;
}
export interface UnionOrIntersection extends BaseType {
    types: Array<Type>;
    kind: TypeKinds.UNION | TypeKinds.INTERSECTION;
}
export interface TypeOperator extends BaseType {
    type: Type;
    kind: TypeKinds.TYPEOF_OPERATOR | TypeKinds.UNIQUE_OPERATOR | TypeKinds.READONLY_OPERATOR | TypeKinds.KEYOF_OPERATOR;
}
export interface TupleMember {
    type: Type;
    spread?: boolean;
    name?: string;
    optional?: boolean;
    jsDoc?: Array<JSDocData>;
}
export interface Tuple extends BaseType {
    types: Array<TupleMember>;
    kind: TypeKinds.TUPLE;
}
export interface ArrayType extends BaseType {
    type: Type;
    kind: TypeKinds.ARRAY_TYPE;
}
export interface ObjectProperty {
    prop?: Property;
    index?: IndexSignatureDeclaration;
    call?: FunctionSignature;
    construct?: FunctionSignature;
    jsDoc?: Array<JSDocData>;
}
export interface InterfaceDecl extends NodeWithManyLOC {
    properties: Array<ObjectProperty>;
    typeParameters?: Array<TypeParameter>;
    extends?: Array<Type>;
    implements?: Array<Type>;
    kind: DeclarationTypes.INTERFACE;
}
export interface TypeDecl extends Node {
    value?: Type;
    typeParameters?: Array<TypeParameter>;
    kind: DeclarationTypes.TYPE_ALIAS;
}
export interface ConstantDecl extends Node {
    type?: Type | undefined;
    content?: string;
    kind: DeclarationTypes.CONSTANT;
}
export interface EnumMember extends Node {
    initializer?: Type;
}
export interface EnumDecl extends NodeWithManyLOC {
    members: Array<EnumMember>;
    isConst: boolean;
    kind: DeclarationTypes.ENUM;
}
export declare const enum MappedTypeModifiers {
    PRESENT = 0,
    NEGATED = 1
}
export interface MappedType extends BaseType {
    typeParameter: string;
    constraint?: Type;
    optional?: MappedTypeModifiers;
    readonly?: MappedTypeModifiers;
    as?: Type;
    type?: Type;
    kind: TypeKinds.MAPPED_TYPE;
}
export interface ConditionalType extends BaseType {
    checkType: Type;
    extendsType: Type;
    trueType: Type;
    falseType: Type;
    kind: TypeKinds.CONDITIONAL_TYPE;
}
export interface TemplateLiteralType extends BaseType {
    head: string;
    spans: Array<{
        type: Type;
        text: string;
    }>;
    kind: TypeKinds.TEMPLATE_LITERAL;
}
export interface IndexAccessedType extends BaseType {
    object: Type;
    index: Type;
    kind: TypeKinds.INDEX_ACCESS;
}
export interface TypePredicateType extends BaseType {
    parameter: Type | string;
    type: Type;
    kind: TypeKinds.TYPE_PREDICATE;
}
export interface InferType extends BaseType {
    typeParameter: Reference;
    kind: TypeKinds.INFER_TYPE;
}
export declare type Declaration = ClassDecl | InterfaceDecl | EnumDecl | FunctionDecl | TypeDecl | ConstantDecl;
//# sourceMappingURL=structure.d.ts.map