/**
 * @public
 */
export declare type ArrayExpression = Node_2 & ArrayExpression2<Expression | SpreadElement>;

/**
 * @public
 */
export declare interface ArrayExpression2<T = Expression2 | SpreadElement2> {
    type: 'ArrayExpression';
    elements: T[];
}

/**
 * @public
 */
export declare type ArrowFunctionExpression = Node_2 & ArrowFunctionExpression2<Pattern, Expression>;

/**
 * @public
 */
export declare interface ArrowFunctionExpression2<T = Pattern2, T2 = Expression2> {
    type: 'ArrowFunctionExpression';
    params: T[];
    body: T2;
}

/**
 * @public
 */
export declare type AssignmentPattern = Node_2 & AssignmentPattern2<Identifier, Expression>;

/**
 * @public
 */
export declare interface AssignmentPattern2<T = Identifier2, T2 = Expression> {
    type: 'AssignmentPattern';
    left: T;
    right: T2;
}

/**
 * @public
 */
export declare type BinaryExpression = Node_2 & BinaryExpression2<Expression>;

/**
 * @public
 */
export declare interface BinaryExpression2<T = Expression2> {
    type: 'BinaryExpression';
    operator: BinaryOperator;
    left: T;
    right: T;
}

/**
 * @public
 */
export declare type BinaryOperator = '**' | '*' | '/' | '%' | '+' | '-' | '<<' | '>>' | '>>>' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '===' | '!==' | '&' | '^' | '|' | '|>';

/**
 * @public
 */
export declare type BooleanLiteral = Node_2 & BooleanLiteral2;

/**
 * @public
 */
export declare interface BooleanLiteral2 {
    type: 'BooleanLiteral';
    value: boolean;
}

/**
 * @public
 */
export declare type CallExpression = Node_2 & CallExpression2<Expression | SpreadElement, Expression>;

/**
 * @public
 */
export declare interface CallExpression2<T = Expression2 | SpreadElement2, T2 = Expression2> {
    type: 'CallExpression';
    callee: T2;
    arguments: T[];
    optional?: boolean;
}

/**
 * @public
 */
export declare type ConditionalExpression = Node_2 & ConditionalExpression2<Expression>;

/**
 * @public
 */
export declare interface ConditionalExpression2<T = Expression2> {
    type: 'ConditionalExpression';
    test: T;
    consequent: T;
    alternate: T;
}

/**
 * @public
 */
export declare interface CustomData {
    add?(right: unknown): unknown;
    added?(left: unknown): unknown;
    subtract?(right: unknown): unknown;
    subtracted?(left: unknown): unknown;
    multiply?(right: unknown): unknown;
    multiplied?(left: unknown): unknown;
    divide?(right: unknown): unknown;
    divided?(left: unknown): unknown;
    remainer?(right: unknown): unknown;
    remainered?(left: unknown): unknown;
    equal?(value: unknown): unknown;
    lessThan?(value: unknown): unknown;
    greaterThan?(value: unknown): unknown;
    lessThanOrEqual?(value: unknown): unknown;
    greaterThanOrEqual?(value: unknown): unknown;
    power?(value: unknown): unknown;
    powered?(value: unknown): unknown;
}

/**
 * @public
 */
export declare const defaultLocale: {
    multipleDecimalPoint: string;
    expect: string;
    unexpectToken: string;
    expectUnaryOperator: string;
    expectConditionalOperator: string;
    invalidPropertyName: string;
    emptyExpression: string;
    invalidFunctionParameter: string;
};

/**
 * @public
 */
export declare interface EOFToken extends Node_2 {
    type: 'EOFToken';
}

/**
 * @public
 */
export declare function evaluateExpression(expression: Expression, context: {
    [name: string]: unknown;
}, locale?: Locale, customData?: Array<{
    new (...args: any[]): unknown;
}> | ((value: unknown) => value is CustomData)): unknown;

/**
 * @public
 */
export declare type Expression = BinaryExpression | MemberExpression | Identifier | NumericLiteral | StringLiteral | ConditionalExpression | CallExpression | LogicalExpression | UnaryExpression | ThisExpression | BooleanLiteral | ArrayExpression | ObjectExpression | NullLiteral | ArrowFunctionExpression | FunctionParamsExpression;

/**
 * @public
 */
export declare type Expression2 = BinaryExpression2 | MemberExpression2 | Identifier2 | NumericLiteral2 | StringLiteral2 | ConditionalExpression2 | CallExpression2 | LogicalExpression2 | UnaryExpression2 | ThisExpression2 | BooleanLiteral2 | ArrayExpression2 | ObjectExpression2 | NullLiteral2 | ArrowFunctionExpression2 | FunctionParamsExpression2;

/**
 * @public
 */
export declare class ExpressionError extends Error {
    range: [number, number];
    constructor(message: string, range: [number, number]);
}

/**
 * @public
 */
export declare type FunctionParamsExpression = Node_2 & FunctionParamsExpression2<Pattern>;

/**
 * @public
 */
export declare interface FunctionParamsExpression2<T = Pattern2> {
    type: 'FunctionParamsExpression';
    params: T[];
}

export declare function getLocale(locale: null | undefined | Locale): Locale;

/**
 * @public
 */
export declare type Identifier = Node_2 & Identifier2;

/**
 * @public
 */
export declare interface Identifier2 {
    type: 'Identifier';
    name: string;
}

/**
 * @public
 */
export declare interface KeywordToken extends Node_2 {
    type: 'KeywordToken';
    name: string;
}

export declare type Locale = typeof defaultLocale;

/**
 * @public
 */
export declare type LogicalExpression = Node_2 & LogicalExpression2<Expression>;

/**
 * @public
 */
export declare interface LogicalExpression2<T = Expression2> {
    type: 'LogicalExpression';
    operator: LogicalOperator;
    left: T;
    right: T;
}

/**
 * @public
 */
export declare type LogicalOperator = '||' | '&&' | '??';

/**
 * @public
 */
export declare type MemberExpression = Node_2 & MemberExpression2<Expression>;

/**
 * @public
 */
export declare interface MemberExpression2<T = Expression2> {
    type: 'MemberExpression';
    object: T;
    property: T;
    optional?: boolean;
}

/**
 * @public
 */
declare interface Node_2 {
    range: [number, number];
    parenthesesRange?: [number, number];
}
export { Node_2 as Node }

/**
 * @public
 */
export declare type NullLiteral = Node_2 & NullLiteral2;

/**
 * @public
 */
export declare interface NullLiteral2 {
    type: 'NullLiteral';
}

/**
 * @public
 */
export declare type NumericLiteral = Node_2 & NumericLiteral2;

/**
 * @public
 */
export declare interface NumericLiteral2 {
    type: 'NumericLiteral';
    value: number;
}

/**
 * @public
 */
export declare type ObjectExpression = Node_2 & ObjectExpression2<Property | SpreadElement>;

/**
 * @public
 */
export declare interface ObjectExpression2<T = Property2 | SpreadElement2> {
    type: 'ObjectExpression';
    properties: T[];
}

/**
 * @public
 */
export declare function parseExpression(tokens: Token[], locale?: Locale): Expression;

/**
 * @public
 */
export declare type Pattern = Identifier | AssignmentPattern | RestElement;

/**
 * @public
 */
export declare type Pattern2 = Identifier2 | AssignmentPattern2 | RestElement2;

export declare const postfixUnaryOperators: string[];

/**
 * @public
 */
export declare function printExpression(expression: Expression2, options?: Partial<{
    keepBinaryExpressionOrder: boolean;
}>): string;

export declare const priorizedBinaryOperators: string[][];

/**
 * @public
 */
export declare type Property = Node_2 & Property2<NumericLiteral | StringLiteral | Identifier>;

/**
 * @public
 */
export declare interface Property2<T = NumericLiteral2 | StringLiteral2 | Identifier2> {
    type: 'Property';
    key: T;
    value: Expression;
    shorthand: boolean;
}

/**
 * @public
 */
export declare interface PunctuatorToken extends Node_2 {
    type: 'PunctuatorToken';
    value: string;
}

export declare function replaceLocaleParameters(locale: string, ...parameters: (number | string)[]): string;

/**
 * @public
 */
export declare type RestElement = Node_2 & RestElement2<Identifier>;

/**
 * @public
 */
export declare interface RestElement2<T = Identifier2> {
    type: 'RestElement';
    argument: T;
}

/**
 * @public
 */
export declare type SpreadElement = Node_2 & SpreadElement2<Expression>;

/**
 * @public
 */
export declare interface SpreadElement2<T = Expression> {
    type: 'SpreadElement';
    argument: T;
}

/**
 * @public
 */
export declare type StringLiteral = Node_2 & StringLiteral2;

/**
 * @public
 */
export declare interface StringLiteral2 {
    type: 'StringLiteral';
    value: string;
}

/**
 * @public
 */
export declare type ThisExpression = Node_2 & ThisExpression2;

/**
 * @public
 */
export declare interface ThisExpression2 {
    type: 'ThisExpression';
}

/**
 * @public
 */
export declare type Token = BooleanLiteral | EOFToken | Identifier | KeywordToken | NumericLiteral | PunctuatorToken | StringLiteral | NullLiteral;

/**
 * @public
 */
export declare function tokenizeExpression(expression: string): Token[];

/**
 * @public
 */
export declare type UnaryExpression = Node_2 & UnaryExpression2<Expression>;

/**
 * @public
 */
export declare interface UnaryExpression2<T = Expression2> {
    type: 'UnaryExpression';
    operator: UnaryOperator;
    argument: T;
}

/**
 * @public
 */
export declare type UnaryOperator = '+' | '-' | '!' | '~' | '%' | 'await';

export { }