import * as config from './config';
export declare enum SymbolKind {
    Invalid = 0,
    Module = 1,
    PrimitiveType = 2,
    Enum = 3,
    EnumMember = 4,
    ObjectType = 5,
    Interface = 6,
    Class = 7,
    Array = 8,
    Function = 9,
    TypeParameter = 10,
    Tuple = 11,
    UnionType = 12,
    IntersectionType = 13,
    BooleanLiteralType = 14,
    StringLiteralType = 15,
    Property = 16,
    Method = 17,
    Signature = 18,
    Parameter = 19,
    Variable = 20,
    TypeAlias = 21,
}
export interface ObjectTable<T> {
    [name: string]: T;
}
export declare class Tag {
    name: string;
    value: string;
    constructor(name: string, value?: string);
    readonly number: number;
    readonly boolean: boolean;
    toString(): string;
}
export declare class DeclarationInfo {
    fileName: string;
    path: string;
    fullText: string;
    lineAndCharacterNumber: {
        line: number;
        character: number;
    };
    constructor(fileName: string, path: string, fullText: string, lineAndCharacterNumber: {
        line: number;
        character: number;
    });
    toString(): string;
}
export declare class Decorator {
    decoratorFunction: Function;
    argumentTable: ObjectTable<any>;
    readonly name: string;
    readonly parameters: Parameter[];
    readonly arguments: any[];
    constructor(decoratorFunction: Function, argumentTable: ObjectTable<any>);
    toString(): string;
}
export declare class TypePredicate {
    type: Type;
    thisType: Type;
    parameter: Parameter;
    constructor(type: Type, thisType: Type, parameter: Parameter);
    toString(): string;
}
export declare class Symbol {
    protected config: config.Config;
    rawName: string;
    docComment: string[];
    declarationInfos: DeclarationInfo[];
    decorators: Decorator[];
    parentModule: Module;
    protected rawAssumedName: string;
    private static tagPattern;
    kind: SymbolKind;
    private isDestroyed;
    constructor(config: config.Config, rawName: string, docComment: string[], declarationInfos: DeclarationInfo[], decorators: Decorator[], parentModule: Module, rawAssumedName: string);
    readonly name: string;
    readonly assumedName: string;
    readonly fullName: string;
    readonly namespace: string[];
    readonly namespaceString: string;
    readonly ancestorModules: Module[];
    readonly comment: string;
    readonly tagTable: ObjectTable<Tag>;
    readonly tags: Tag[];
    readonly isAnonymous: boolean;
    readonly isAnonymousType: boolean;
    readonly isType: boolean;
    readonly isGenericType: boolean;
    readonly isGlobalModule: boolean;
    readonly isModule: boolean;
    readonly isPrimitiveType: boolean;
    readonly isEnum: boolean;
    readonly isEnumMember: boolean;
    readonly isObjectType: boolean;
    readonly isInterface: boolean;
    readonly isClass: boolean;
    readonly isArray: boolean;
    readonly isFunction: boolean;
    readonly isTypeParameter: boolean;
    readonly isTuple: boolean;
    readonly isUnionType: boolean;
    readonly isIntersectionType: boolean;
    readonly isBooleanLiteralType: boolean;
    readonly isStringLiteralType: boolean;
    readonly isProperty: boolean;
    readonly isMethod: boolean;
    readonly isSignature: boolean;
    readonly isParameter: boolean;
    readonly isVariable: boolean;
    readonly isTypeAlias: boolean;
    readonly isGenerationTarget: boolean;
    toString(): string;
    validate(): void;
    destroy(ok?: boolean): void;
}
export declare class Type extends Symbol {
    readonly isType: boolean;
}
export declare class Module extends Symbol {
    kind: SymbolKind;
    isNamespaceModule: boolean;
    importedModuleTable: ObjectTable<Module>;
    importedTypeTable: ObjectTable<Type>;
    modules: Module[];
    types: Type[];
    anonymousTypes: Type[];
    variables: Variable[];
    typeAliases: TypeAlias[];
    readonly enums: Enum[];
    readonly functions: Function[];
    readonly interfaces: Interface[];
    readonly classes: Class[];
    readonly isGlobalModule: boolean;
    readonly name: string;
    readonly importedModules: {
        name: string;
        module: Module;
    }[];
    readonly importedTypes: {
        name: string;
        type: Type;
    }[];
    initialize(isNamespaceModule: boolean, importedModuleTable: ObjectTable<Module>, importedTypeTable: ObjectTable<Type>, modules: Module[], types: Type[], variables: Variable[], typeAliases: TypeAlias[]): Module;
}
export declare class PrimitiveType extends Type {
    kind: SymbolKind;
    readonly isGenerationTarget: boolean;
    initialize(rawName: string): PrimitiveType;
    validate(): void | string;
}
export declare class Enum extends Type {
    kind: SymbolKind;
    members: EnumMember[];
    isConst: boolean;
    initialize(members: EnumMember[], isConst: boolean): Enum;
}
export declare class EnumMember extends Symbol {
    kind: SymbolKind;
    value: number;
    initialize(value: number): EnumMember;
}
export declare class Function extends Type {
    kind: SymbolKind;
    callSignatures: Signature[];
    initialize(callSignatures: Signature[]): Function;
    validate(): void | string;
}
export declare class ObjectType extends Type {
    kind: SymbolKind;
    properties: Property[];
    methods: Method[];
    builtInSymbolMethods: Method[];
    stringIndexType: Type;
    numberIndexType: Type;
    readonly ownProperties: Property[];
    readonly ownMethods: Method[];
    initialize(properties: Property[], methods: Method[], builtInSymbolMethods: Method[], stringIndexType: Type, numberIndexType: Type, ...forOverride: any[]): ObjectType;
    validate(): void | string;
}
export declare class TypeReference {
    typeParameters: TypeParameter[];
    private rawTypeArguments;
    readonly typeArguments: Type[];
    constructor(typeParameters: TypeParameter[], rawTypeArguments: Type[]);
    getTypeByTypeParameter(typeParameter: TypeParameter): Type;
}
export declare class Interface extends ObjectType {
    kind: SymbolKind;
    constructorSignatures: Signature[];
    callSignatures: Signature[];
    baseTypes: Interface[];
    typeReference: TypeReference;
    staticProperties: Property[];
    staticMethods: Method[];
    isAbstract: boolean;
    readonly isGenericType: boolean;
    readonly typeParameters: Type[];
    readonly typeArguments: Type[];
    readonly assumedName: string;
    initialize(properties: Property[], methods: Method[], builtInSymbolMethods: Method[], stringIndexType: Type, numberIndexType: Type, constructorSignatures: Signature[], callSignatures: Signature[], baseTypes: Interface[], typeReference: TypeReference, staticProperties: Property[], staticMethods: Method[], isAbstract: boolean): Interface;
    validate(): void | string;
}
export declare class Class extends Interface {
    kind: SymbolKind;
}
export declare class Array extends Type {
    kind: SymbolKind;
    type: Type;
    readonly isGenerationTarget: boolean;
    readonly assumedName: string;
    initialize(type: Type): Array;
}
export declare class TypeParameter extends Type {
    kind: SymbolKind;
    constraint: Type;
    initialize(constraint: Type): TypeParameter;
}
export declare class Tuple extends Type {
    kind: SymbolKind;
    types: Type[];
    readonly assumedName: string;
    initialize(types: Type[]): Tuple;
    validate(): void | string;
}
export declare class UnionType extends Type {
    kind: SymbolKind;
    types: Type[];
    readonly assumedName: string;
    initialize(types: Type[]): UnionType;
    validate(): void | string;
}
export declare class IntersectionType extends Type {
    kind: SymbolKind;
    types: Type[];
    readonly assumedName: string;
    initialize(types: Type[]): UnionType;
    validate(): void | string;
}
export declare class StringLiteralType extends Type {
    kind: SymbolKind;
    text: string;
    readonly rawText: string;
    readonly assumedName: string;
    initialize(text: string): StringLiteralType;
}
export declare class BooleanLiteralType extends Type {
    kind: SymbolKind;
    rawText: string;
    readonly assumedName: string;
    initialize(rawText: string): BooleanLiteralType;
}
export declare class Property extends Symbol {
    kind: SymbolKind;
    type: Type;
    isOptional: boolean;
    isOwn: boolean;
    isProtected: boolean;
    initialize(type: Type, isOptional: boolean, isOwn: boolean, isProtected: boolean): Property;
}
export declare class Method extends Symbol {
    kind: SymbolKind;
    callSignatures: Signature[];
    isOptional: boolean;
    isOwn: boolean;
    isProtected: boolean;
    isAbstract: boolean;
    initialize(callSignatures: Signature[], isOptional: boolean, isOwn: boolean, isProtected: boolean, isAbstract: boolean): Method;
    validate(): void | string;
}
export declare class Signature extends Symbol {
    kind: SymbolKind;
    typeParameters: TypeParameter[];
    parameters: Parameter[];
    returnType: Type;
    typePredicate: TypePredicate;
    initialize(typeParameters: TypeParameter[], parameters: Parameter[], returnType: Type, typePredicate: TypePredicate): Signature;
    validate(): void | string;
}
export declare class Parameter extends Symbol {
    kind: SymbolKind;
    type: Type;
    isOptional: boolean;
    isVariadic: boolean;
    initialize(type: Type, isOptional: boolean, isVariadic: boolean): Parameter;
}
export declare class Variable extends Symbol {
    kind: SymbolKind;
    type: Type;
    module: Module;
    isLet: boolean;
    isConst: boolean;
    initialize(type: Type, module: Module, isLet: boolean, isConst: boolean): Variable;
}
export declare class TypeAlias extends Symbol {
    kind: SymbolKind;
    type: Type;
    initialize(type: Type): TypeAlias;
}