import { CompleterModel, CompletionHandler } from '@jupyterlab/completer';
import { CompletionItem } from './item';
interface ICompletionMatch<T extends CompletionHandler.ICompletionItem> {
    /**
     * A score which indicates the strength of the match.
     *
     * A lower score is better. Zero is the best possible score.
     */
    score: number;
    item: T;
}
/**
 * A lot of this was contributed upstream
 */
export declare class GenericCompleterModel<T extends CompletionHandler.ICompletionItem> extends CompleterModel {
    settings: GenericCompleterModel.IOptions;
    constructor(settings?: GenericCompleterModel.IOptions);
    completionItems(): T[];
    protected harmoniseItem(item: CompletionHandler.ICompletionItem): T;
    private _markFragment;
    protected getFilterText(item: T): string;
    protected getHighlightableLabelRegion(item: T): string;
    createPatch(patch: string): import("@jupyterlab/completer").Completer.IPatch | undefined;
    protected resolveQuery(userQuery: string, _item: T): string;
    private _sortAndFilter;
    protected compareMatches(a: ICompletionMatch<T>, b: ICompletionMatch<T>): number;
}
export declare namespace GenericCompleterModel {
    interface IOptions {
        /**
         * Whether matching should be case-sensitive (default = true)
         */
        caseSensitive?: boolean;
        /**
         * Whether perfect matches should be included (default = true)
         */
        includePerfectMatches?: boolean;
        /**
         * Whether kernel completions should be shown first.
         */
        kernelCompletionsFirst?: boolean;
    }
    const defaultOptions: IOptions;
}
type MaybeCompletionItem = Partial<CompletionItem> & CompletionHandler.ICompletionItem;
export declare class LSPCompleterModel extends GenericCompleterModel<MaybeCompletionItem> {
    settings: LSPCompleterModel.IOptions;
    constructor(settings?: LSPCompleterModel.IOptions);
    protected getFilterText(item: MaybeCompletionItem): string;
    setCompletionItems(newValue: MaybeCompletionItem[]): void;
    protected resolveQuery(userQuery: string, item: MaybeCompletionItem): string;
    protected harmoniseItem(item: CompletionHandler.ICompletionItem): any;
    protected compareMatches(a: ICompletionMatch<MaybeCompletionItem>, b: ICompletionMatch<MaybeCompletionItem>): number;
    private _preFilterQuery;
}
export declare namespace LSPCompleterModel {
    interface IOptions extends GenericCompleterModel.IOptions {
        /**
         * Whether matches should be pre-filtered (default = true)
         */
        preFilterMatches?: boolean;
    }
    const defaultOptions: IOptions;
}
export {};