import type { Effect } from 'effect';
import type { IOperatorDef, ASTMeta, ITypeCheckerBase, IContextBase, IFullEvaluator, ITypeDeclaration, IASTNode } from './types.js.js';
import type { Limits } from './options.js.js';
export declare class ASTNode {
    #private;
    op: string;
    args: unknown;
    pos: number;
    start: number;
    end: number;
    constructor(input: string, pos: number, start: number, end: number, op: IOperatorDef, args: unknown);
    clone(op: IOperatorDef, args: unknown): ASTNode;
    get meta(): ASTMeta;
    get input(): string;
    check(chk: ITypeCheckerBase, ast: IASTNode, ctx: IContextBase): ITypeDeclaration;
    evaluate(ev: IFullEvaluator, ast: IASTNode, ctx: IContextBase): Effect.Effect<unknown, unknown>;
    setMeta(key: string, value: unknown): this;
    get range(): {
        start: number;
        end: number;
    };
    toOldStructure(): unknown[];
}
declare class Lexer {
    #private;
    input: string;
    pos: number;
    length: number;
    tokenPos: number;
    tokenType: number;
    tokenValue: unknown;
    reset(input: string): string;
    token(pos: number, type: number, value?: unknown): this;
    nextToken(): this;
    _isIdentifierCharCode(c: number): boolean;
    _parseAsNumber(start: number, end: number): this;
    _parseAsHexNumber(start: number, end: number): this;
    _readDigits(input: string, length: number, pos: number, code?: number): number;
    _readExponent(input: string, length: number, pos: number): number;
    readNumber(): this;
    readString(del: string, prefix?: string): this;
    _closeQuotedString(rawStart: number, rawValue: string, prefix: string | undefined, pos: number): this;
    readSingleQuotedString(delimiter: string, prefix?: string): this;
    readTripleQuotedString(delimiter: string, prefix?: string): this;
    processEscapes(offset: number, str: string, isBytes: boolean): string;
    readIdentifier(): this;
}
interface IParserRegistry {
    findMacro(name: string, hasReceiver: boolean, argLen: number): {
        handler: (...args: unknown[]) => unknown;
    } | false | null | undefined;
}
export declare class Parser {
    #private;
    lexer: Lexer;
    input: string | undefined;
    maxDepthRemaining: number | undefined;
    astNodesRemaining: number | undefined;
    type: number | undefined;
    pos: number | undefined;
    limits: Limits;
    registry: IParserRegistry;
    constructor(limits: Limits, registry: IParserRegistry);
    get value(): unknown;
    consume(expectedType: number): number;
    match(type: number): boolean;
    parse(input: unknown): ASTNode;
    parseExpression(): ASTNode;
    parseLogicalOr(): ASTNode;
    parseLogicalAnd(): ASTNode;
    parseEquality(): ASTNode;
    parseRelational(): ASTNode;
    parseAdditive(): ASTNode;
    parseMultiplicative(): ASTNode;
    parseUnary(): ASTNode;
    parsePostfix(): ASTNode;
    parsePrimary(): ASTNode;
    parseList(): ASTNode;
    parseListElement(): ASTNode;
    parseMap(): ASTNode;
    parseProperty(): [ASTNode, ASTNode] | [ASTNode];
    parseArgumentList(): ASTNode[];
}
export {};
