import { IExpressionUtil } from "./i-expression-util";
import { ICodeAnalyzer } from "@wessberg/codeanalyzer";
import { RawExpressionBindable } from "../../expression/raw-expression-bindable/raw-expression-bindable";
import { IContext } from "../context-util/i-context";
import { RawExpressionChainBindable } from "../../expression/raw-expression-chain-bindable/raw-expression-chain-bindable";
/**
 * A utility class for working with expressions
 */
export declare class ExpressionUtil implements IExpressionUtil {
    private readonly codeAnalyzer;
    /**
     * The thing to prepend "this." with inside identifiers
     * @type {string}
     */
    private readonly SCOPE_NAME;
    /**
     * The prefix to add before host properties
     * @type {string}
     */
    private readonly HOST_PREFIX;
    constructor(codeAnalyzer: ICodeAnalyzer);
    /**
     * Formats an Expression Chain from some content
     * @param {string} content
     * @param {IContext} context
     * @returns {RawExpressionChainBindable}
     */
    formatExpressionChain(content: string, context: IContext): RawExpressionChainBindable;
    /**
     * Formats an Expression from some content
     * @param {string} content
     * @param {IContext} context
     * @returns {RawExpressionBindable}
     */
    formatExpression(content: string, context: IContext): RawExpressionBindable | string;
    /**
     * Gets proper ExpressionContent for the given Statements
     * @param {NodeArray<Node> | Node} statements
     * @param {string} originalContent
     * @param {IContext} context
     * @returns {IGenerateExpressionContentResult}
     */
    private getExpressionContent;
    /**
     * Generates ExpressionContent from the computed statements within an expression
     * @param {NodeArray<Node> | Node} statements
     * @param {string} originalContent
     * @param {string[]} [environment]
     * @param {IExpressionContentPartMetadata} metadata
     * @param {Node} [parent]
     * @param {string} [suffix]
     * @returns {IExpressionContentPart[]}
     */
    private generateExpressionContent;
    /**
     * Wraps an expression
     * @param {string} expression
     * @param {string[]} nonIdentifiers
     * @returns {IExpressionContentPart}
     */
    private wrapIdentifier;
    /**
     * Wraps an expression
     * @param {string} expression
     * @returns {IExpressionContentPart}
     */
    private wrapExpression;
    /**
     * Returns true if the node can be provided to an arrow function that implicitly returns
     * @param {Node} node
     * @returns {boolean}
     */
    private supportsImplicitReturns;
}