import type ts from 'typescript';
export type TypeInfoCommon = {
    tsRawType: string;
    isOptional?: boolean;
    tsMetadata: {
        typeFlags: Array<keyof typeof ts.TypeFlags>;
        type?: ts.Type;
    };
};
export type TypeInfo = ({
    type: 'string' | 'number' | 'boolean';
} & TypeInfoCommon) | ({
    type: 'stringLiteral';
    value: string;
} & TypeInfoCommon) | ({
    type: 'numberLiteral';
    value: number;
} & TypeInfoCommon) | ({
    type: 'union';
    items: TypeInfo[];
} & TypeInfoCommon) | ({
    type: 'array';
    items: TypeInfo;
} & TypeInfoCommon) | ({
    type: 'object';
    properties: Record<string, SymbolInfo>;
} & TypeInfoCommon) | ({
    type: 'function';
    parameters: SymbolInfo[];
    returnType?: TypeInfo;
    typeParameters?: TypeInfo[];
} & TypeInfoCommon) | ({
    type: 'class';
    properties: Record<string, SymbolInfo>;
    constructorParameters: SymbolInfo[];
    constructorReturnType: TypeInfo;
    prototype: SymbolInfo;
} & TypeInfoCommon) | ({
    type: 'unknown';
} & TypeInfoCommon) | ({
    type: 'any';
} & TypeInfoCommon) | ({
    type: 'misc';
} & TypeInfoCommon);
/**
 * Where a property symbol was declared. `getDeclaringInterface` only returns
 * this object when it could resolve a containing interface or type alias —
 * absent declarations get `undefined` instead, so both fields here are
 * guaranteed present whenever the value exists.
 */
export type SymbolDeclaringInterface = {
    /** Name of the interface/type-alias that declares this symbol. */
    interfaceName: string;
    /**
     * True when every declaration of this symbol lives inside a known React DOM
     * type interface (`HTMLAttributes`, `*HTMLAttributes`, `DOMAttributes`,
     * `AriaAttributes`, `SVGAttributes`, etc.). Used by renderers to filter the
     * inherited DOM-attribute deluge from inferred specs.
     */
    isReactDomInterface: boolean;
};
export type SymbolInfo = {
    name: string;
    jsDoc?: {
        description?: string;
        jsDocTags: Array<{
            name: string;
            text?: string;
        }>;
    };
    typeInfo: TypeInfo;
    tsMetadata: {
        symbol?: ts.Symbol;
        type?: ts.Type;
        symbolFlags: Array<keyof typeof ts.SymbolFlags>;
    };
    /**
     * Where this symbol is declared. Populated only for properties of object
     * types (i.e. component props). Absent for synthetic or unresolvable symbols.
     */
    declaredIn?: SymbolDeclaringInterface;
};
//# sourceMappingURL=types.d.ts.map