/**
 * The two pattern grammars: a binding pattern (`const {a, b} = value`,
 * `const [first, ...rest] = items`) and a `case` pattern, including the literal
 * values a case may test against. Both are recursive, and both re-enter through
 * the host's `withParseDepth` so one budget covers the whole nest.
 */
import type { BindingPattern, Expression, MatchStatement, TypeReference } from "../ast.ts";
import { type Diagnostic } from "../diagnostic.ts";
import { type Span } from "../source.ts";
import { type Token, type TokenKind } from "../token.ts";
export interface PatternParserHost {
    advance(): Token;
    check(kind: TokenKind): boolean;
    checkWord(value: string): boolean;
    current(): Token;
    readonly diagnostics: Diagnostic[];
    expect(kind: TokenKind, message: string): Token;
    expectMemberName(message?: string): Token;
    match(kind: TokenKind): boolean;
    matchWord(value: string): boolean;
    numberLiteral(token: Token, negative?: boolean, literalSpan?: Span): Extract<Expression, {
        kind: "LiteralExpression";
    }>;
    parseTypeReference(allowTrailingOptional?: boolean, initialized?: boolean): TypeReference;
    peekKind(distance: number): TokenKind;
    previous(): Token;
    reservedWordMessage(noun: string): string | null;
    withParseDepth<T>(parse: () => T): T;
}
export declare class PatternParser {
    private readonly host;
    constructor(host: PatternParserHost);
    parseBindingPattern(): BindingPattern;
    private parseBindingPatternBody;
    parseMatchPattern(root: boolean): MatchStatement["cases"][number]["pattern"];
    private parseMatchPatternBody;
    private parseMatchValue;
    private startsMatchValue;
}
//# sourceMappingURL=patterns.d.ts.map