import { INodeToDictMapperBase } from "./i-node-to-dict-mapper";
import { AccessorDeclaration, ArrayBindingElement, ArrayBindingPattern, BindingElement, BindingName, CallSignatureDeclaration, ClassElement, ConstructorDeclaration, ConstructSignatureDeclaration, Decorator, ExportSpecifier, FunctionLikeDeclaration, GetAccessorDeclaration, HeritageClause, Identifier, ImportClause, ImportSpecifier, IndexSignatureDeclaration, InterfaceDeclaration, MethodDeclaration, MethodSignature, ModifiersArray, ObjectBindingPattern, ParameterDeclaration, PropertyDeclaration, PropertySignature, SetAccessorDeclaration, SignatureDeclaration, TypeElement, TypeLiteralNode } from "typescript";
import { IDecoratorDict } from "../light-ast/dict/decorator/i-decorator-dict";
import { IObjectBindingElementDict } from "../light-ast/dict/binding-element/i-object-binding-element-dict";
import { ArrayBindingElementDict, INormalArrayBindingElementDict, IOmittedArrayBindingElementDict } from "../light-ast/dict/binding-element/array-binding-element-dict";
import { BindingNameDict, IArrayBindingNameDict, INormalBindingNameDict, IObjectBindingNameDict } from "../light-ast/dict/binding-name/binding-name-dict";
import { IParameterDict } from "../light-ast/dict/parameter/i-parameter-dict";
import { ITypeElementDict, TypeElementDict } from "../light-ast/dict/type-element/i-type-element-dict";
import { ICallSignatureDict } from "../light-ast/dict/call-signature/i-call-signature-dict";
import { IConstructSignatureDict } from "../light-ast/dict/construct-signature/i-construct-signature-dict";
import { IMethodSignatureDict } from "../light-ast/dict/method-signature/i-method-signature-dict";
import { IIndexSignatureDict } from "../light-ast/dict/index-signature/i-index-signature-dict";
import { IPropertySignatureDict } from "../light-ast/dict/property-signature/i-property-signature-dict";
import { ISignatureDict } from "../light-ast/dict/signature/i-signature-dict";
import { HeritageDict, IExtendsHeritageDict, IImplementsHeritageDict } from "../light-ast/dict/heritage/i-heritage-dict";
import { ITypeLiteralDict } from "../light-ast/dict/type-literal/i-type-literal-dict";
import { IInterfaceDict } from "../light-ast/dict/interface/i-interface-dict";
import { INamedImportExportDict } from "../light-ast/dict/named-import-export/i-named-import-export-dict";
import { IImportClauseDict } from "../light-ast/dict/import-clause/i-import-clause-dict";
import { IAllModifiersDict } from "../light-ast/dict/modifier/i-all-modifiers-dict";
import { IClassDict } from "../light-ast/dict/class/i-class-dict";
import { ClassElementDict } from "../light-ast/dict/class-element/class-element-dict";
import { ClassAccessorDict } from "../light-ast/dict/class-accessor/class-accessor-dict";
import { NodeToCtorMapper } from "../node-to-ctor-mapper/node-to-ctor-mapper";
import { AccessorDict, IAccessorDict, IGetAccessorDict, ISetAccessorDict } from "../light-ast/dict/accessor/accessor-dict";
import { IClassMethodDict } from "../light-ast/dict/class-method/i-class-method-dict";
import { IClassPropertyDict } from "../light-ast/dict/class-property/i-class-property-dict";
import { IFunctionLikeDict } from "../light-ast/dict/function-like/i-function-like-dict";
import { IFunctionLikeWithParametersDict } from "../light-ast/dict/function-like-with-parameters/i-function-like-with-parameters-dict";
import { IMethodDict } from "../light-ast/dict/method/i-method-dict";
import { IConstructorDict } from "../light-ast/dict/constructor/i-constructor-dict";
import { Optional } from "../optional/optional";
import { Class } from "../service/class/i-class-service";
/**
 * A class that can map nodes to dicts
 */
export declare class NodeToDictMapper extends NodeToCtorMapper implements INodeToDictMapperBase {
    /**
     * Maps a Decorator to an IDecoratorDict
     * @param {Decorator} node
     * @returns {IDecoratorDict}
     */
    toIDecoratorDict(node: Optional<Decorator>): IDecoratorDict | null;
    /**
     * Maps a BindingElement to an IObjectBindingNameElementDict
     * @param {BindingElement} node
     * @returns {IObjectBindingElementDict}
     */
    toIObjectBindingElementDict(node: Optional<BindingElement>): IObjectBindingElementDict | null;
    /**
     * Maps a BindingElement to an INormalArrayBindingElementDict
     * @param {BindingElement} node
     * @returns {INormalArrayBindingElementDict}
     */
    toINormalArrayBindingElementDict(node: Optional<BindingElement>): INormalArrayBindingElementDict | null;
    /**
     * Maps an ArrayBindingElement to an IOmittedArrayBindingElementDict
     * @param {ArrayBindingElement?} node
     * @returns {IOmittedArrayBindingElementDict}
     */
    toIOmittedArrayBindingElementDict(node: Optional<ArrayBindingElement>): IOmittedArrayBindingElementDict | null;
    /**
     * Maps an ArrayBindingElement to an ArrayBindingElementDict
     * @param {ArrayBindingElement} node
     * @returns {ArrayBindingElementDict}
     */
    toArrayBindingElementDict(node: Optional<ArrayBindingElement>): ArrayBindingElementDict | null;
    /**
     * Maps a BindingName to a BindingNameDict
     * @param {BindingName} node
     * @returns {BindingNameDict}
     */
    toBindingNameDict(node: Optional<BindingName>): BindingNameDict | null;
    /**
     * Maps an Identifier to an INormalBindingNameDict
     * @param {Identifier} node
     * @returns {INormalBindingNameDict}
     */
    toINormalBindingNameDict(node: Optional<Identifier>): INormalBindingNameDict | null;
    /**
     * Maps an ObjectBindingPattern to an IObjectBindingNameDict
     * @param {ObjectBindingPattern} node
     * @returns {IObjectBindingNameDict}
     */
    toIObjectBindingNameDict(node: Optional<ObjectBindingPattern>): IObjectBindingNameDict | null;
    /**
     * Maps an ArrayBindingPattern to an IArrayBindingNameDict
     * @param {ArrayBindingPattern} node
     * @returns {IArrayBindingNameDict}
     */
    toIArrayBindingNameDict(node: Optional<ArrayBindingPattern>): IArrayBindingNameDict | null;
    /**
     * Maps a ParameterDeclaration to an IParameterDict
     * @param {ParameterDeclaration} node
     * @returns {IParameterDict}
     */
    toIParameterDict(node: Optional<ParameterDeclaration>): IParameterDict | null;
    /**
     * Maps a TypeElement to a TypeElementDict
     * @param {TypeElement} node
     * @returns {TypeElementDict}
     */
    toTypeElementDict(node: Optional<TypeElement>): TypeElementDict | null;
    /**
     * Maps a CallSignatureDeclaration to an ICallSignatureDict
     * @param {CallSignatureDeclaration} node
     * @returns {ICallSignatureDict}
     */
    toICallSignatureDict(node: Optional<CallSignatureDeclaration>): ICallSignatureDict | null;
    /**
     * Maps a ConstructSignatureDeclaration to an IConstructSignatureDict
     * @param {ConstructSignatureDeclaration} node
     * @returns {IConstructSignatureDict}
     */
    toIConstructSignatureDict(node: Optional<ConstructSignatureDeclaration>): IConstructSignatureDict | null;
    /**
     * Maps a MethodSignature to an IMethodSignatureDict
     * @param {MethodSignature} node
     * @returns {IMethodSignatureDict}
     */
    toIMethodSignatureDict(node: Optional<MethodSignature>): IMethodSignatureDict | null;
    /**
     * Maps an IndexSignatureDeclaration to an IIndexSignatureDict
     * @param {IndexSignatureDeclaration} node
     * @returns {IIndexSignatureDict}
     */
    toIIndexSignatureDict(node: Optional<IndexSignatureDeclaration>): IIndexSignatureDict | null;
    /**
     * Maps a PropertySignature to an IPropertySignatureDict
     * @param {PropertySignature} node
     * @returns {IPropertySignatureDict}
     */
    toIPropertySignatureDict(node: Optional<PropertySignature>): IPropertySignatureDict | null;
    /**
     * Maps a SignatureDeclaration to an ISignatureDict
     * @param {SignatureDeclaration} node
     * @returns {ISignatureDict}
     */
    toISignatureDict(node: Optional<SignatureDeclaration>): ISignatureDict | null;
    /**
     * Maps a HeritageClause to an IExtendsHeritageDict, if possible
     * @param {HeritageClause} node
     * @returns {IExtendsHeritageDict}
     */
    toIExtendsHeritageDict(node: Optional<HeritageClause>): IExtendsHeritageDict | null;
    /**
     * Maps a HeritageClause to an IImplementsHeritageDict, if possible
     * @param {HeritageClause} node
     * @returns {IImplementsHeritageDict}
     */
    toIImplementsHeritageDict(node: Optional<HeritageClause>): IImplementsHeritageDict | null;
    /**
     * Maps a HeritageClause to a HeritageDict
     * @param {HeritageClause} node
     * @returns {HeritageDict}
     */
    toHeritageDict(node: Optional<HeritageClause>): HeritageDict | null;
    /**
     * Maps a TypeLiteralNode to a TypeLiteralDict
     * @param {TypeLiteralNode|InterfaceDeclaration} node
     * @returns {ITypeLiteralDict}
     */
    toITypeLiteralDict(node: Optional<TypeLiteralNode | InterfaceDeclaration>): ITypeLiteralDict | null;
    /**
     * Maps an InterfaceDeclaration to an IInterfaceDict
     * @param {InterfaceDeclaration} node
     * @returns {IInterfaceDict}
     */
    toIInterfaceDict(node: Optional<InterfaceDeclaration>): IInterfaceDict | null;
    /**
     * Maps a TypeElement to an ITypeElementDict
     * @param {TypeElement} node
     * @returns {ITypeElementDict}
     */
    toITypeElementDict(node: Optional<TypeElement>): ITypeElementDict | null;
    /**
     * Maps a ModifiersArray to an IAllModifiersDict
     * @param {Optional<ModifiersArray>} modifiers
     * @returns {IAllModifiersDict | null}
     */
    toIAllModifiersDict(modifiers: Optional<ModifiersArray>): IAllModifiersDict | null;
    /**
     * Maps a Class to an IClassDict
     * @param {Optional<Class>} node
     * @returns {IClassDict | null}
     */
    toIClassDict(node: Optional<Class>): IClassDict | null;
    /**
     * Maps a ClassElement to an ClassElementDict
     * @param {Optional<ClassElement>} node
     * @returns {ClassElementDict | null}
     */
    toClassElementDict(node: Optional<ClassElement>): ClassElementDict | null;
    /**
     * Maps a AccessorDeclaration to an ClassAccessorDict
     * @param {Optional<AccessorDeclaration>} node
     * @returns {ClassAccessorDict | null}
     */
    toClassAccessorDict(node: Optional<AccessorDeclaration>): ClassAccessorDict | null;
    /**
     * Maps a ConstructorDeclaration to an IConstructorDict
     * @param {Optional<ConstructorDeclaration>} node
     * @returns {IConstructorDict | null}
     */
    toIConstructorDict(node: ConstructorDeclaration | null | undefined): IConstructorDict | null;
    /**
     * Maps a MethodDeclaration to an IClassMethodDict
     * @param {Optional<MethodDeclaration>} node
     * @returns {IClassMethodDict | null}
     */
    toIClassMethodDict(node: MethodDeclaration | null | undefined): IClassMethodDict | null;
    /**
     * Maps an PropertyDeclaration to an IClassPropertyDict
     * @param {Optional<PropertyDeclaration>} node
     * @returns {IClassPropertyDict | null}
     */
    toIClassPropertyDict(node: PropertyDeclaration | null | undefined): IClassPropertyDict | null;
    /**
     * Maps a MethodDeclaration to an IMethodDict
     * @param {Optional<MethodDeclaration>} node
     * @returns {IMethodDict | null}
     */
    toIMethodDict(node: MethodDeclaration | null | undefined): IMethodDict | null;
    /**
     * Maps an FunctionLikeDeclaration to an IFunctionLikeDict
     * @param {Optional<FunctionLikeDeclaration>} node
     * @returns {IFunctionLikeDict | null}
     */
    toIFunctionLikeDict(node: FunctionLikeDeclaration | null | undefined): IFunctionLikeDict | null;
    /**
     * Maps a FunctionLikeDeclaration to an IFunctionLikeWithParametersDict
     * @param {Optional<FunctionLikeDeclaration>} node
     * @returns {IFunctionLikeWithParametersDict | null}
     */
    toIFunctionLikeWithParametersDict(node: FunctionLikeDeclaration | null | undefined): IFunctionLikeWithParametersDict | null;
    /**
     * Maps an AccessorDeclaration to an AccessorDict
     * @param {Optional<AccessorDeclaration>} node
     * @returns {AccessorDict | null}
     */
    toAccessorDict(node: AccessorDeclaration | null | undefined): AccessorDict | null;
    /**
     * Maps an AccessorDeclaration to an IAccessorDict
     * @param {Optional<AccessorDeclaration>} node
     * @returns {IAccessorDict | null}
     */
    toIAccessorDict(node: AccessorDeclaration | null | undefined): IAccessorDict | null;
    /**
     * Maps a GetAccessorDeclaration to an IGetAccessorDict
     * @param {Optional<GetAccessorDeclaration>} node
     * @returns {IGetAccessorDict | null}
     */
    toIGetAccessorDict(node: GetAccessorDeclaration | null | undefined): IGetAccessorDict | null;
    /**
     * Maps a SetAccessorDeclaration to an ISetAccessorDict
     * @param {Optional<SetAccessorDeclaration>} node
     * @returns {ISetAccessorDict | null}
     */
    toISetAccessorDict(node: SetAccessorDeclaration | null | undefined): ISetAccessorDict | null;
    /**
     * Maps an ImportSpecifier to an INamedImportExportDict
     * @param {ImportSpecifier|ExportSpecifier?} node
     * @returns {INamedImportExportDict?}
     */
    toINamedImportExportDict(node: Optional<ImportSpecifier | ExportSpecifier>): INamedImportExportDict | null;
    /**
     * Maps an ImportClause to an IImportClauseDict
     * @param {ImportClause?} node
     * @returns {IImportClauseDict?}
     */
    toIImportClauseDict(node: Optional<ImportClause>): IImportClauseDict | null;
}