import { IJoinerBase } from "./i-joiner";
import { Block, ClassElement, Declaration, Decorator, Expression, HeritageClause, NamedExports, NamedImports, NodeArray, Statement } from "typescript";
import { IHeritageClauseService } from "../service/heritage-clause/i-heritage-clause-service";
import { INamedImportsService } from "../service/named-imports/i-named-imports-service";
import { INamedExportsService } from "../service/named-exports/i-named-exports-service";
import { IPlacement } from "../placement/i-placement";
/**
 * A class for joining multiple different Nodes together to form new ones
 */
export declare class Joiner implements IJoinerBase {
    private readonly heritageClauseService;
    private readonly namedImportsService;
    private readonly namedExportsService;
    constructor(heritageClauseService: IHeritageClauseService, namedImportsService: INamedImportsService, namedExportsService: INamedExportsService);
    /**
     * Joins two NodeArrays of Statements
     * @param {NodeArray<Statement>|Statement} newStatements
     * @param {NodeArray<Statement>} existingStatements
     * @param {IPlacement} [placement]
     * @returns {NodeArray<Statement>}
     */
    joinStatementNodeArrays(newStatements: NodeArray<Statement> | Statement, existingStatements: NodeArray<Statement> | undefined, placement?: IPlacement): NodeArray<Statement>;
    /**
     * Joins two arrays of Expressions
     * @param {NodeArray<Expression> | Expression} newExpressions
     * @param {NodeArray<Expression>} existingExpressions
     * @param {IPlacement} [placement]
     * @returns {NodeArray<Expression>}
     */
    joinExpressionNodeArrays(newExpressions: NodeArray<Expression> | Expression, existingExpressions: NodeArray<Expression> | undefined, placement?: IPlacement): NodeArray<Expression>;
    /**
     * Joins two arrays of Declarations
     * @param {NodeArray<Declaration> | Declaration} newDeclarations
     * @param {NodeArray<Declaration>} existingDeclarations
     * @param {IPlacement} [placement]
     * @returns {NodeArray<Declaration>}
     */
    joinDeclarationNodeArrays(newDeclarations: NodeArray<Declaration> | Declaration, existingDeclarations: NodeArray<Declaration> | undefined, placement?: IPlacement): NodeArray<Declaration>;
    /**
     * Joins the provided Decorators
     * @param {Decorator | undefined} decorators
     * @returns {ts.NodeArray<Decorator>}
     */
    joinDecorators(...decorators: (Decorator | undefined)[]): NodeArray<Decorator>;
    /**
     * Joins the provided ClassElements
     * @param {ClassElement} elements
     * @returns {NodeArray<ClassElement>}
     */
    joinClassElements(...elements: (ClassElement | undefined)[]): NodeArray<ClassElement>;
    /**
     * Joins the provided HeritageClauses
     * @param {HeritageClause} clauses
     * @returns {NodeArray<HeritageClause>}
     */
    joinHeritageClauses(...clauses: (HeritageClause | undefined)[]): NodeArray<HeritageClause>;
    /**
     * Joins two implements clauses. Takes all of the unique types
     * @param {HeritageClause} newImplementsClause
     * @param {HeritageClause} existingImplementsClause
     * @returns {HeritageClause}
     */
    joinImplementsHeritageClause(newImplementsClause: HeritageClause, existingImplementsClause: HeritageClause | undefined): HeritageClause;
    /**
     * Joins two independent Blocks
     * @param {Block} blocks
     * @returns {Block}
     */
    joinBlock(...blocks: (Block | undefined)[]): Block;
    /**
     * Joins two NamedImports
     * @param {NamedImports} newNamedImports
     * @param {NamedImports} existingNamedImports
     * @returns {NamedImports}
     */
    joinNamedImports(newNamedImports: NamedImports, existingNamedImports: NamedImports | undefined): NamedImports;
    /**
     * Joins two NamedExports
     * @param {NamedExports} newNamedExports
     * @param {NamedExports} existingNamedExports
     * @returns {NamedExports}
     */
    joinNamedExports(newNamedExports: NamedExports, existingNamedExports: NamedExports | undefined): NamedExports;
    /**
     * Joins two NodeArrays of Nodes
     * @param {NodeArray<Node>|Node} newNodes
     * @param {NodeArray<Node>} existingNodes
     * @param {IPlacement} [placement]
     * @returns {NodeArray<Node>}
     */
    private joinNodeArrays;
}