/**
 * What may follow a primary expression: calls with named arguments, member and
 * optional-member access, indexing, and an explicit type-argument list — which
 * is only a type-argument list when the token run between `<` and `>` can be
 * one, since every other `<` is a comparison.
 */
import type { Expression } from "../../ast.ts";
import { type Diagnostic } from "../../diagnostic.ts";
import { type Token, type TokenKind } from "../../token.ts";
export interface PostfixParserHost {
    advance(): Token;
    check(kind: TokenKind): boolean;
    current(): Token;
    readonly diagnostics: Diagnostic[];
    expect(kind: TokenKind, message: string): Token;
    expectMemberName(message?: string): Token;
    readonly genericCallableNames: ReadonlySet<string>;
    index: number;
    match(kind: TokenKind): boolean;
    parseExpression(minimumPrecedence?: number): Expression;
    parsePrimary(): Expression;
    parseSpreadExpression(): Expression;
    peekKind(distance: number): TokenKind;
    previous(): Token;
    readonly tokens: Token[];
}
export declare class PostfixParser {
    private readonly host;
    constructor(host: PostfixParserHost);
    parsePostfix(): Expression;
    /**
     * One call's argument list, read from just after `(` to just before `)`.
     * The two named-argument spellings and the positional-before-named rule are
     * one decision, so they are answered in one place; `sawSpread` never leaves
     * this list because the only rule that reads it is inside it.
     */
    private parseCallArguments;
    private explicitTypeArgumentsEnd;
    private recoverChainedNamedArgument;
}
//# sourceMappingURL=postfix.d.ts.map