import { AccessorDeclaration, ArrayBindingElement, ArrayBindingPattern, BindingElement, BindingName, CallSignatureDeclaration, ClassDeclaration, ClassElement, ClassExpression, 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 { INodeToCtorMapperBase } from "./i-node-to-ctor-mapper";
import { IHeritageClauseService } from "../service/heritage-clause/i-heritage-clause-service";
import { IInterfaceDeclarationService } from "../service/interface-declaration/i-interface-declaration-service";
import { IPropertyNameService } from "../service/property-name/i-property-name-service";
import { IPropertySignatureService } from "../service/property-signature/i-property-signature-service";
import { IMethodSignatureService } from "../service/method-signature/i-method-signature-service";
import { IIndexSignatureService } from "../service/index-signature/i-index-signature-service";
import { IModifierService } from "../service/modifier/i-modifier-service";
import { ITypeNodeService } from "../service/type-node/i-type-node-service";
import { IParameterService } from "../service/parameter/i-parameter-service";
import { IBindingElementService } from "../service/binding-element/i-binding-element-service";
import { IDecoratorService } from "../service/decorator/i-decorator-service";
import { IPrinter } from "@wessberg/typescript-ast-util";
import { IDecoratorCtor } from "../light-ast/ctor/decorator/i-decorator-ctor";
import { IObjectBindingElementCtor } from "../light-ast/ctor/binding-element/i-object-binding-element-ctor";
import { ArrayBindingElementCtor, INormalArrayBindingElementCtor, IOmittedArrayBindingElementCtor } from "../light-ast/ctor/binding-element/array-binding-element-ctor";
import { BindingNameCtor, IArrayBindingNameCtor, INormalBindingNameCtor, IObjectBindingNameCtor } from "../light-ast/ctor/binding-name/binding-name-ctor";
import { IParameterCtor } from "../light-ast/ctor/parameter/i-parameter-ctor";
import { ITypeElementCtor, TypeElementCtor } from "../light-ast/ctor/type-element/i-type-element-ctor";
import { ICallSignatureCtor } from "../light-ast/ctor/call-signature/i-call-signature-ctor";
import { IConstructSignatureCtor } from "../light-ast/ctor/construct-signature/i-construct-signature-ctor";
import { IMethodSignatureCtor } from "../light-ast/ctor/method-signature/i-method-signature-ctor";
import { IIndexSignatureCtor } from "../light-ast/ctor/index-signature/i-index-signature-ctor";
import { IPropertySignatureCtor } from "../light-ast/ctor/property-signature/i-property-signature-ctor";
import { ISignatureCtor } from "../light-ast/ctor/signature/i-signature-ctor";
import { HeritageCtor, IExtendsHeritageCtor, IImplementsHeritageCtor } from "../light-ast/ctor/heritage/i-heritage-ctor";
import { ITypeLiteralCtor } from "../light-ast/ctor/type-literal/i-type-literal-ctor";
import { IInterfaceCtor } from "../light-ast/ctor/interface/i-interface-ctor";
import { INamedImportExportCtor } from "../light-ast/ctor/named-import-export/i-named-import-export-ctor";
import { IImportClauseCtor } from "../light-ast/ctor/import-clause/i-import-clause-ctor";
import { IAllModifiersCtor } from "../light-ast/ctor/modifier/i-all-modifiers-ctor";
import { IClassCtor } from "../light-ast/ctor/class/i-class-ctor";
import { IClassService } from "../service/class/i-class-service";
import { ClassElementCtor } from "../light-ast/ctor/class-element/class-element-ctor";
import { ClassAccessorCtor } from "../light-ast/ctor/class-accessor/class-accessor-ctor";
import { AccessorCtor, IAccessorCtor, IGetAccessorCtor, ISetAccessorCtor } from "../light-ast/ctor/accessor/accessor-ctor";
import { IGetAccessorService } from "../service/get-accessor/i-get-accessor-service";
import { ISetAccessorService } from "../service/set-accessor/i-set-accessor-service";
import { IFunctionLikeCtor } from "../light-ast/ctor/function-like/i-function-like-ctor";
import { IClassPropertyCtor } from "../light-ast/ctor/class-property/i-class-property-ctor";
import { IClassMethodCtor } from "../light-ast/ctor/class-method/i-class-method-ctor";
import { IMethodCtor } from "../light-ast/ctor/method/i-method-ctor";
import { IMethodService } from "../service/method/i-method-service";
import { IFunctionLikeWithParametersCtor } from "../light-ast/ctor/function-like-with-parameters/i-function-like-with-parameters-ctor";
import { IConstructorCtor } from "../light-ast/ctor/constructor/i-constructor-ctor";
import { Optional } from "../optional/optional";
/**
 * A class that can map nodes to ctor's
 */
export declare class NodeToCtorMapper implements INodeToCtorMapperBase {
    protected readonly heritageClauseService: IHeritageClauseService;
    protected readonly interfaceDeclarationService: IInterfaceDeclarationService;
    protected readonly propertyNameService: IPropertyNameService;
    protected readonly methodService: IMethodService;
    protected readonly propertySignatureService: IPropertySignatureService;
    protected readonly methodSignatureService: IMethodSignatureService;
    protected readonly indexSignatureService: IIndexSignatureService;
    protected readonly getAccessorService: IGetAccessorService;
    protected readonly setAccessorService: ISetAccessorService;
    protected readonly classService: IClassService;
    protected readonly modifierService: IModifierService;
    protected readonly typeNodeService: ITypeNodeService;
    protected readonly parameterService: IParameterService;
    protected readonly bindingElementService: IBindingElementService;
    protected readonly decoratorService: IDecoratorService;
    protected readonly printer: IPrinter;
    constructor(heritageClauseService: IHeritageClauseService, interfaceDeclarationService: IInterfaceDeclarationService, propertyNameService: IPropertyNameService, methodService: IMethodService, propertySignatureService: IPropertySignatureService, methodSignatureService: IMethodSignatureService, indexSignatureService: IIndexSignatureService, getAccessorService: IGetAccessorService, setAccessorService: ISetAccessorService, classService: IClassService, modifierService: IModifierService, typeNodeService: ITypeNodeService, parameterService: IParameterService, bindingElementService: IBindingElementService, decoratorService: IDecoratorService, printer: IPrinter);
    /**
     * Maps a Decorator to an IDecoratorCtor
     * @param {Decorator} node
     * @returns {IDecoratorCtor}
     */
    toIDecoratorCtor(node: Optional<Decorator>): IDecoratorCtor | null;
    /**
     * Maps a ModifiersArray to an IAllModifiersCtor
     * @param {ModifiersArray | null | undefined} modifiers
     * @returns {IAllModifiersCtor | null}
     */
    toIAllModifiersCtor(modifiers: Optional<ModifiersArray>): IAllModifiersCtor | null;
    /**
     * Maps a BindingElement to an IObjectBindingNameElementCtor
     * @param {BindingElement} node
     * @returns {IObjectBindingElementCtor}
     */
    toIObjectBindingElementCtor(node: Optional<BindingElement>): IObjectBindingElementCtor | null;
    /**
     * Maps a BindingElement to an INormalArrayBindingElementCtor
     * @param {BindingElement} node
     * @returns {INormalArrayBindingElementCtor}
     */
    toINormalArrayBindingElementCtor(node: Optional<BindingElement>): INormalArrayBindingElementCtor | null;
    /**
     * Maps an ArrayBindingElement to an IOmittedArrayBindingElementCtor
     * @param {ArrayBindingElement} _node
     * @returns {IOmittedArrayBindingElementCtor}
     */
    toIOmittedArrayBindingElementCtor(_node: Optional<ArrayBindingElement>): IOmittedArrayBindingElementCtor | null;
    /**
     * Maps an ArrayBindingElement to an ArrayBindingElementCtor
     * @param {ArrayBindingElement} node
     * @returns {ArrayBindingElementCtor}
     */
    toArrayBindingElementCtor(node: Optional<ArrayBindingElement>): ArrayBindingElementCtor | null;
    /**
     * Maps a BindingName to a BindingNameCtor
     * @param {BindingName} node
     * @returns {BindingNameCtor}
     */
    toBindingNameCtor(node: Optional<BindingName>): BindingNameCtor | null;
    /**
     * Maps an Identifier to an INormalBindingNameCtor
     * @param {Identifier} node
     * @returns {INormalBindingNameCtor}
     */
    toINormalBindingNameCtor(node: Optional<Identifier>): INormalBindingNameCtor | null;
    /**
     * Maps an ObjectBindingPattern to an IObjectBindingNameCtor
     * @param {ObjectBindingPattern} node
     * @returns {IObjectBindingNameCtor}
     */
    toIObjectBindingNameCtor(node: Optional<ObjectBindingPattern>): IObjectBindingNameCtor | null;
    /**
     * Maps an ArrayBindingPattern to an IArrayBindingNameCtor
     * @param {ArrayBindingPattern} node
     * @returns {IArrayBindingNameCtor}
     */
    toIArrayBindingNameCtor(node: Optional<ArrayBindingPattern>): IArrayBindingNameCtor | null;
    /**
     * Maps a ParameterDeclaration to an IParameterCtor
     * @param {ParameterDeclaration} node
     * @returns {IParameterCtor}
     */
    toIParameterCtor(node: Optional<ParameterDeclaration>): IParameterCtor | null;
    /**
     * Maps a TypeElement to a TypeElementCtor
     * @param {TypeElement} node
     * @returns {TypeElementCtor}
     */
    toTypeElementCtor(node: Optional<TypeElement>): TypeElementCtor | null;
    /**
     * Maps a CallSignatureDeclaration to an ICallSignatureCtor
     * @param {CallSignatureDeclaration} node
     * @returns {ICallSignatureCtor}
     */
    toICallSignatureCtor(node: Optional<CallSignatureDeclaration>): ICallSignatureCtor | null;
    /**
     * Maps a ConstructSignatureDeclaration to an IConstructSignatureCtor
     * @param {ConstructSignatureDeclaration} node
     * @returns {IConstructSignatureCtor}
     */
    toIConstructSignatureCtor(node: Optional<ConstructSignatureDeclaration>): IConstructSignatureCtor | null;
    /**
     * Maps a MethodSignature to an IMethodSignatureCtor
     * @param {MethodSignature} node
     * @returns {IMethodSignatureCtor}
     */
    toIMethodSignatureCtor(node: Optional<MethodSignature>): IMethodSignatureCtor | null;
    /**
     * Maps an IndexSignatureDeclaration to an IIndexSignatureCtor
     * @param {IndexSignatureDeclaration} node
     * @returns {IIndexSignatureCtor}
     */
    toIIndexSignatureCtor(node: Optional<IndexSignatureDeclaration>): IIndexSignatureCtor | null;
    /**
     * Maps a PropertySignature to an IPropertySignatureCtor
     * @param {PropertySignature} node
     * @returns {IPropertySignatureCtor}
     */
    toIPropertySignatureCtor(node: Optional<PropertySignature>): IPropertySignatureCtor | null;
    /**
     * Maps a SignatureDeclaration to an ISignatureCtor
     * @param {SignatureDeclaration} node
     * @returns {ISignatureCtor}
     */
    toISignatureCtor(node: Optional<SignatureDeclaration>): ISignatureCtor | null;
    /**
     * Maps a HeritageClause to an IExtendsHeritageCtor, if possible
     * @param {HeritageClause} node
     * @returns {IExtendsHeritageCtor}
     */
    toIExtendsHeritageCtor(node: Optional<HeritageClause>): IExtendsHeritageCtor | null;
    /**
     * Maps a HeritageClause to an IImplementsHeritageCtor, if possible
     * @param {HeritageClause} node
     * @returns {IImplementsHeritageCtor}
     */
    toIImplementsHeritageCtor(node: Optional<HeritageClause>): IImplementsHeritageCtor | null;
    /**
     * Maps a HeritageClause to a HeritageCtor
     * @param {HeritageClause} node
     * @returns {HeritageCtor}
     */
    toHeritageCtor(node: Optional<HeritageClause>): HeritageCtor | null;
    /**
     * Maps a TypeLiteralNode to a TypeLiteralCtor
     * @param {TypeLiteralNode|InterfaceDeclaration} node
     * @returns {ITypeLiteralCtor}
     */
    toITypeLiteralCtor(node: Optional<TypeLiteralNode | InterfaceDeclaration>): ITypeLiteralCtor | null;
    /**
     * Maps an InterfaceDeclaration to an IInterfaceCtor
     * @param {InterfaceDeclaration} node
     * @returns {IInterfaceCtor}
     */
    toIInterfaceCtor(node: Optional<InterfaceDeclaration>): IInterfaceCtor | null;
    /**
     * Maps a TypeElement to an ITypeElementCtor
     * @param {TypeElement} node
     * @returns {ITypeElementCtor}
     */
    toITypeElementCtor(node: Optional<TypeElement>): ITypeElementCtor | null;
    /**
     * Maps a Class to an IClassCtor
     * @param {ClassDeclaration | ClassExpression | null | undefined} node
     * @returns {IClassCtor | null}
     */
    toIClassCtor(node: Optional<ClassDeclaration | ClassExpression>): IClassCtor | null;
    /**
     * Maps a ClassElement to a ClassElementCtor
     * @param {ClassElement|null|?} node
     * @returns {ClassElementCtor|null}
     */
    toClassElementCtor(node: Optional<ClassElement>): ClassElementCtor | null;
    /**
     * Maps a AccessorDeclaration to a ClassAccessorCtor
     * @param {AccessorDeclaration| null | undefined} node
     * @returns {ClassAccessorCtor | null}
     */
    toClassAccessorCtor(node: Optional<AccessorDeclaration>): ClassAccessorCtor | null;
    /**
     * Maps a ConstructorDeclaration to a IConstructorCtor
     * @param {ConstructorDeclaration | null | undefined} node
     * @returns {IConstructorCtor | null}
     */
    toIConstructorCtor(node: Optional<ConstructorDeclaration>): IConstructorCtor | null;
    /**
     * Maps a MethodDeclaration to a IClassMethodCtor
     * @param {MethodDeclaration| null | undefined} node
     * @returns {IClassMethodCtor | null}
     */
    toIClassMethodCtor(node: Optional<MethodDeclaration>): IClassMethodCtor | null;
    /**
     * Maps a PropertyDeclaration to a IClassPropertyCtor
     * @param {AccessorDeclaration| null | undefined} node
     * @returns {IClassPropertyCtor | null}
     */
    toIClassPropertyCtor(node: Optional<PropertyDeclaration>): IClassPropertyCtor | null;
    /**
     * Maps a MethodDeclaration to a IMethodCtor
     * @param {MethodDeclaration| null | undefined} node
     * @returns {IMethodCtor | null}
     */
    toIMethodCtor(node: Optional<MethodDeclaration>): IMethodCtor | null;
    /**
     * Maps a FunctionLikeDeclaration to an IFunctionLikeCtor
     * @param {FunctionLikeDeclaration | null | undefined} node
     * @returns {IFunctionLikeCtor | null}
     */
    toIFunctionLikeCtor(node: Optional<FunctionLikeDeclaration>): IFunctionLikeCtor | null;
    /**
     * Maps a FunctionLikeDeclaration to a IFunctionLikeWithParametersCtor
     * @param {FunctionLikeDeclaration| null | undefined} node
     * @returns {IMethodCtor | null}
     */
    toIFunctionLikeWithParametersCtor(node: Optional<FunctionLikeDeclaration>): IFunctionLikeWithParametersCtor | null;
    /**
     * Maps a AccessorDeclaration to a AccessorCtor
     * @param {AccessorDeclaration| null | undefined} node
     * @returns {AccessorCtor | null}
     */
    toAccessorCtor(node: Optional<AccessorDeclaration>): AccessorCtor | null;
    /**
     * Maps a AccessorDeclaration to an IAccessorCtor
     * @param {AccessorDeclaration| null | undefined} node
     * @returns {IAccessorCtor | null}
     */
    toIAccessorCtor(node: Optional<AccessorDeclaration>): IAccessorCtor | null;
    /**
     * Maps a GetAccessorDeclaration to an IGetAccessorCtor
     * @param {GetAccessorDeclaration | null | undefined} node
     * @returns {IGetAccessorCtor | null}
     */
    toIGetAccessorCtor(node: Optional<GetAccessorDeclaration>): IGetAccessorCtor | null;
    /**
     * Maps a SetAccessorDeclaration to an ISetAccessorCtor
     * @param {SetAccessorDeclaration | null | undefined} node
     * @returns {ISetAccessorCtor | null}
     */
    toISetAccessorCtor(node: Optional<SetAccessorDeclaration>): ISetAccessorCtor | null;
    /**
     * Maps an ImportSpecifier to an INamedImportExportCtor
     * @param {ImportSpecifier|ExportSpecifier?} node
     * @returns {INamedImportExportCtor?}
     */
    toINamedImportExportCtor(node: Optional<ImportSpecifier | ExportSpecifier>): INamedImportExportCtor | null;
    /**
     * Maps an ImportClause to an IImportClauseCtor
     * @param {ImportClause?} node
     * @returns {IImportClauseCtor?}
     */
    toIImportClauseCtor(node: Optional<ImportClause>): IImportClauseCtor | null;
    /**
     * Makes sure that the provided item will fallback to null rather than undefined if it is undefined
     * @param {T} item
     * @returns {T}
     */
    fallbackToNull<T>(item: T | undefined): T | null;
}