import { DeclaratorASTNode } from "../../../ast/ast_declarators";
import { SemanticContext, TranslationUnitContext } from "../../compilation/contexts";
import { QualifiedName, UnqualifiedName } from "../../compilation/lexical";
import { AnalyticConstruct } from "../../../analysis/predicates";
import { Type } from "../../compilation/types";
import { SuccessfullyCompiled } from "../CPPConstruct";
import { BasicCPPConstruct } from "../BasicCPPConstruct";
import { CompiledParameterDeclaration, ParameterDeclaration } from "./function/ParameterDeclaration";
export declare class Declarator extends BasicCPPConstruct<TranslationUnitContext, DeclaratorASTNode> {
    isSemanticallyEquivalent_impl(other: AnalyticConstruct, equivalenceContext: SemanticContext): boolean;
    readonly construct_type = "declarator";
    readonly name?: UnqualifiedName | QualifiedName;
    readonly type?: Type;
    readonly baseType?: Type;
    readonly isPureVirtual?: true;
    readonly isOverride?: true;
    readonly hasConstructorName: boolean;
    readonly hasDestructorName: boolean;
    readonly parameters?: readonly ParameterDeclaration[];
    static createFromAST(ast: DeclaratorASTNode | undefined, context: TranslationUnitContext, baseType: Type | undefined): Declarator;
    /**
     * `Declarator.createFromAST()` should always be used to create Declarators, which delegates
     * to this private constructor. Directly calling the constructor from the outside is not allowed.
     * Since declarators are largely about processing an AST, it doesn't make much sense to create
     * one without an AST.
     */
    private constructor();
    private determineNameAndType;
    private processFunctionDeclarator;
}
export interface TypedDeclarator<T extends Type> extends Declarator {
    type: T;
}
export interface CompiledDeclarator<T extends Type = Type> extends TypedDeclarator<T>, SuccessfullyCompiled {
    readonly parameters?: readonly CompiledParameterDeclaration[];
}