import { Tree, TreeFragment, NodeProp, Input, PartialParse, ParseContext } from "lezer-tree";
import { Parser, ParserConfig } from "lezer";
import { EditorState, Extension, Facet } from "@codemirror/next/state";
export declare const languageDataProp: NodeProp<Facet<{
    [name: string]: any;
}, readonly {
    [name: string]: any;
}[]>>;
export declare function defineLanguageFacet(baseData?: {
    [name: string]: any;
}): Facet<{
    [name: string]: any;
}, readonly {
    [name: string]: any;
}[]>;
export declare class Language {
    readonly data: Facet<{
        [name: string]: any;
    }>;
    readonly extension: Extension;
    parser: {
        startParse: (input: Input, startPos: number, context: ParseContext) => PartialParse;
    };
    constructor(data: Facet<{
        [name: string]: any;
    }>, parser: {
        startParse(input: Input, pos: number, context: EditorParseContext): PartialParse;
    }, extraExtensions?: Extension[]);
    isActiveAt(state: EditorState, pos: number): boolean;
    findRegions(state: EditorState): {
        from: number;
        to: number;
    }[];
    get allowsNesting(): boolean;
    parseString(code: string): Tree;
}
export declare class LezerLanguage extends Language {
    readonly parser: Parser;
    private constructor();
    static define(spec: {
        parser: Parser;
        languageData?: {
            [name: string]: any;
        };
    }): LezerLanguage;
    configure(options: ParserConfig): LezerLanguage;
    get allowsNesting(): boolean;
}
export declare function syntaxTree(state: EditorState): Tree;
export declare function ensureSyntaxTree(state: EditorState, upto: number, timeout?: number): Tree | null;
export declare class EditorParseContext implements ParseContext {
    private parser;
    readonly state: EditorState;
    fragments: readonly TreeFragment[];
    viewport: {
        from: number;
        to: number;
    };
    private parse;
    private withoutTempSkipped;
    skipUntilInView(from: number, to: number): void;
    static skippingParser: {
        startParse(input: Input, startPos: number, context: ParseContext): PartialParse;
    };
}
export declare const language: Facet<Language, Language | null>;
export declare class LanguageSupport {
    readonly language: Language;
    readonly support: Extension;
    extension: Extension;
    constructor(language: Language, support?: Extension);
}
export declare class LanguageDescription {
    readonly name: string;
    readonly alias: readonly string[];
    readonly extensions: readonly string[];
    readonly filename: RegExp | undefined;
    private loadFunc;
    support: LanguageSupport | undefined;
    private loading;
    private constructor();
    load(): Promise<LanguageSupport>;
    static of(spec: {
        name: string;
        alias?: readonly string[];
        extensions?: readonly string[];
        filename?: RegExp;
        load: () => Promise<LanguageSupport>;
    }): LanguageDescription;
    static matchFilename(descs: readonly LanguageDescription[], filename: string): LanguageDescription | null;
    static matchLanguageName(descs: readonly LanguageDescription[], name: string, fuzzy?: boolean): LanguageDescription | null;
}
//# sourceMappingURL=language.d.ts.map