import * as config from './config';
export declare enum SymbolKind {
    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,
    IndexType = 14,
    IndexedAccessType = 15,
    StringLiteralType = 16,
    BooleanLiteralType = 17,
    NumberLiteralType = 18,
    EnumLiteralType = 19,
    Property = 20,
    Method = 21,
    Signature = 22,
    Parameter = 23,
    Variable = 24,
    TypeAlias = 25,
}
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 IndexInfo {
    type: Type;
    isReadonly: boolean;
    constructor(type: Type, isReadonly?: boolean);
    toString(): string;
}
export declare class Symbol {
    protected config: config.Config;
    rawName: string;
    docComment: string[];
    declarationInfos: DeclarationInfo[];
    decorators: Decorator[];
    parentModule: Module | null;
    protected rawAssumedName: string;
    private static tagPattern;
    kind: SymbolKind;
    private isDestroyed;
    constructor(config: config.Config, rawName: string, docComment: string[], declarationInfos: DeclarationInfo[], decorators: Decorator[], parentModule: Module | null, rawAssumedName: string);
    readonly name: string;
    private readonly nameWithoutRenaming;
    readonly assumedName: string;
    readonly fullName: string;
    readonly rawFullName: string;
    readonly namespace: string;
    readonly ancestorModules: Module[];
    readonly comment: string;
    readonly tagTable: ObjectTable<Tag>;
    readonly tags: Tag[];
    readonly isAnonymous: boolean;
    readonly isAnonymousType: boolean;
    readonly isGenericType: boolean;
    readonly isGlobalModule: boolean;
    readonly isType: boolean;
    readonly isModule: boolean;
    readonly isPrimitiveType: boolean;
    readonly isEnum: boolean;
    readonly isEnumMember: boolean;
    readonly isObjectLikeType: 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 isIndexType: boolean;
    readonly isIndexedAccessType: boolean;
    readonly isLiteralType: boolean;
    readonly isStringLiteralType: boolean;
    readonly isBooleanLiteralType: boolean;
    readonly isNumberLiteralType: boolean;
    readonly isEnumLiteralType: 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;
}
export declare class Type extends Symbol {
}
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;
    }[];
}
export declare class PrimitiveType extends Type {
    kind: SymbolKind;
    readonly isGenerationTarget: boolean;
    validate(): void | string;
}
export declare class Enum extends Type {
    kind: SymbolKind;
    members: EnumMember[];
    isConst: boolean;
}
export declare class EnumMember extends Symbol {
    kind: SymbolKind;
    value: number;
}
export declare class Function extends Type {
    kind: SymbolKind;
    callSignatures: Signature[];
    validate(): void | string;
}
export declare class ObjectLikeType extends Type {
    properties: Property[];
    methods: Method[];
    builtInSymbolMethods: Method[];
    stringIndex: IndexInfo | null;
    numberIndex: IndexInfo | null;
    readonly ownProperties: Property[];
    readonly ownMethods: Method[];
    validate(): void | string;
}
export declare class ObjectType extends ObjectLikeType {
    kind: SymbolKind;
    templateType: Type | null;
    basedMappedType: ObjectType | null;
    readonly assumedName: string;
    readonly indexedAccessType: IndexedAccessType | null;
    readonly isMappedType: boolean;
    static createEmptyObjectType(config: config.Config): ObjectType;
    validate(): void | string;
    private getAssumedNameFromIndexedAccessType(indexedAccessType);
}
export declare class TypeReference {
    typeParameters: TypeParameter[];
    private rawTypeArguments;
    readonly typeArguments: Type[];
    constructor(typeParameters: TypeParameter[], rawTypeArguments: Type[]);
    getTypeByTypeParameter(typeParameter: TypeParameter): Type | null;
}
export declare class Interface extends ClassOrInterface {
    kind: SymbolKind;
}
export declare class Class extends ClassOrInterface {
    kind: SymbolKind;
}
export declare class Array extends Type {
    kind: SymbolKind;
    type: Type;
    readonly isGenerationTarget: boolean;
    readonly assumedName: string;
}
export declare class TypeParameter extends Type {
    kind: SymbolKind;
    constraint: Type | null;
}
export declare class Tuple extends Type {
    kind: SymbolKind;
    types: Type[];
    readonly assumedName: string;
    validate(): void | string;
}
export declare class UnionType extends Type {
    kind: SymbolKind;
    types: Type[];
    readonly assumedName: string;
    validate(): void | string;
}
export declare class IntersectionType extends Type {
    kind: SymbolKind;
    types: Type[];
    readonly assumedName: string;
    validate(): void | string;
}
export declare class IndexType extends Type {
    kind: SymbolKind;
    type: Type;
    readonly assumedName: string;
}
export declare class IndexedAccessType extends Type {
    kind: SymbolKind;
    objectType: Type;
    indexType: Type;
    constraint: Type | null;
    readonly assumedName: string;
}
export declare class LiteralType extends Type {
    validate(): void | string;
}
export declare class StringLiteralType extends LiteralType {
    kind: SymbolKind;
    text: string;
    readonly rawText: string;
    readonly assumedName: string;
}
export declare class BooleanLiteralType extends LiteralType {
    kind: SymbolKind;
    value: boolean;
    readonly assumedName: string;
}
export declare class NumberLiteralType extends LiteralType {
    kind: SymbolKind;
    value: number;
    readonly assumedName: string;
}
export declare class EnumLiteralType extends LiteralType {
    kind: SymbolKind;
    enumType: Enum;
    enumMember: EnumMember;
    readonly assumedName: string;
}
export declare class Property extends Symbol {
    kind: SymbolKind;
    type: Type;
    isOptional: boolean;
    isOwn: boolean;
    isProtected: boolean;
    isReadonly: boolean;
    isAbstract: boolean;
}
export declare class Method extends Symbol {
    kind: SymbolKind;
    callSignatures: Signature[];
    isOptional: boolean;
    isOwn: boolean;
    isAbstract: boolean;
    validate(): void | string;
}
export declare class Signature extends Symbol {
    kind: SymbolKind;
    typeParameters: TypeParameter[];
    parameters: Parameter[];
    returnType: Type;
    typePredicate: TypePredicate | null;
    isProtected: boolean;
    readonly isGenericSignature: boolean;
    validate(): void | string;
}
export declare class Parameter extends Symbol {
    kind: SymbolKind;
    type: Type;
    isOptional: boolean;
    isVariadic: boolean;
}
export declare class Variable extends Symbol {
    kind: SymbolKind;
    type: Type | null;
    module: Module | null;
    isLet: boolean;
    isConst: boolean;
}
export declare class TypeAlias extends Symbol {
    kind: SymbolKind;
    type: Type;
}