import { NodeService } from "../node/node-service";
import { ClassFunctionLike } from "./class-function-like";
import { IClassFunctionLikeService } from "./i-class-function-like-service";
import { ITypescriptLanguageService } from "@wessberg/typescript-language-service";
import { IRemover } from "../../remover/i-remover-base";
import { ITypescriptASTUtil } from "@wessberg/typescript-ast-util";
import { IDecoratorService } from "../decorator/i-decorator-service";
import { ITypeNodeService } from "../type-node/i-type-node-service";
import { IPropertyNameService } from "../property-name/i-property-name-service";
import { VisibilityKind } from "../../light-ast/dict/visibility/visibility-kind";
import { IModifierService } from "../modifier/i-modifier-service";
import { IUpdater } from "../../updater/i-updater-getter";
import { IFormatter } from "../../formatter/i-formatter-getter";
import { IJoiner } from "../../joiner/i-joiner-getter";
import { INodeToDictMapper } from "../../node-to-dict-mapper/i-node-to-dict-mapper-getter";
import { ReturnStatement } from "typescript";
/**
 * An abstract service for working with ClassFunctionLikes
 */
export declare abstract class ClassFunctionLikeService<T extends ClassFunctionLike> extends NodeService<T> implements IClassFunctionLikeService<T> {
    protected typeNodeService: ITypeNodeService;
    protected propertyNameService: IPropertyNameService;
    protected modifierService: IModifierService;
    protected formatter: IFormatter;
    protected nodeToDictMapper: INodeToDictMapper;
    constructor(typeNodeService: ITypeNodeService, propertyNameService: IPropertyNameService, modifierService: IModifierService, formatter: IFormatter, nodeToDictMapper: INodeToDictMapper, joiner: IJoiner, updater: IUpdater, remover: IRemover, decoratorService: IDecoratorService, languageService: ITypescriptLanguageService, astUtil: ITypescriptASTUtil);
    /**
     * Changes the visibility of the given PropertyDeclaration
     * @template T
     * @param {VisibilityKind} visibility
     * @param {PropertyDeclaration} member
     * @returns {T}
     */
    changeVisibility(visibility: VisibilityKind, member: T): T;
    /**
     * Gets the name of the given member
     * @template T
     * @param {T} member
     * @returns {string}
     */
    getName(member: T): string;
    /**
     * Returns true if the provided method is optional
     * @template T
     * @param {T} member
     * @returns {boolean}
     */
    isOptional(member: T): boolean;
    /**
     * Gets the type of the ClassFunctionLike
     * @template T
     * @param {T} member
     * @returns {string}
     */
    getTypeName(member: T): string | undefined;
    /**
     * Appends the provided instructions to the provided member
     * @template T
     * @param {string} instructions
     * @param {T} member
     * @returns {T}
     */
    abstract appendInstructions(instructions: string, member: T): T;
    /**
     * Takes the ReturnStatement of the member's body, if it has any
     * @template T
     * @param {T} method
     * @returns {ReturnStatement}
     */
    takeReturnStatement(method: T): ReturnStatement | undefined;
}