import { Expression, type TypedExpression, type Expressions, type StrictExpressions } from './expression.js';
import { ExpressionType } from './expression-type.js';
import type { ExpressionVisitor } from './visitors/expression-visitor.js';
/**
 * Represents a call expression.
 * @template T
 * @template TMethod
 * @extends {Expression}
 */
export declare class CallExpression<T, TMethod extends keyof T> extends Expression {
    readonly source: TypedExpression<T>;
    readonly method: TypedExpression<TMethod>;
    readonly optional: boolean;
    /**
     * Gets the type of the expression.
     * @returns {ExpressionType.CallExpression} The type of the expression.
     */
    get type(): ExpressionType.CallExpression;
    readonly arguments: Expressions[];
    /**
     * Creates an instance of CallExpression.
     * @param {TypedExpression<T>} source - The source expression.
     * @param {TypedExpression<TMethod>} method - The method expression.
     * @param {StrictExpressions[]} args - The arguments of the call expression.
     */
    constructor(source: TypedExpression<T>, method: TypedExpression<TMethod>, args: StrictExpressions[], optional: boolean);
    /**
     * Accepts a visitor.
     * @param {ExpressionVisitor} visitor - The visitor to accept.
     * @returns {any} The result of the visitor's visit.
     */
    accept(visitor: ExpressionVisitor): StrictExpressions;
}