type FffResult<T> = {
    ok: true;
    value: T;
} | {
    ok: false;
    error: string;
};
type FffFileItem = {
    relativePath: string;
    fileName?: string;
    size?: number;
    modified?: number;
    gitStatus?: string;
    totalFrecencyScore?: number;
};
type FffSearchResult = {
    items: FffFileItem[];
    scores?: Array<{
        total?: number;
        matchType?: string;
        exactMatch?: boolean;
    }>;
    totalMatched?: number;
    totalFiles?: number;
};
type FffGrepMatch = {
    relativePath: string;
    lineNumber: number;
    lineContent?: string;
    contextBefore?: Array<{
        lineNumber: number;
        lineContent: string;
    }>;
    contextAfter?: Array<{
        lineNumber: number;
        lineContent: string;
    }>;
    isDefinition?: boolean;
};
type FffGrepResult = {
    items: FffGrepMatch[];
    totalMatched?: number;
    totalFilesSearched?: number;
    totalFiles?: number;
    filteredFileCount?: number;
    nextCursor?: unknown;
    regexFallbackError?: string;
};
type FffFinder = {
    waitForScan(timeoutMs?: number): Promise<FffResult<boolean>>;
    fileSearch(query: string, options?: {
        pageSize?: number;
        pageIndex?: number;
    }): FffResult<FffSearchResult>;
    glob(pattern: string, options?: {
        pageSize?: number;
        pageIndex?: number;
    }): FffResult<FffSearchResult>;
    grep(query: string, options?: {
        mode?: "plain" | "regex" | "fuzzy";
        smartCase?: boolean;
        beforeContext?: number;
        afterContext?: number;
        pageSize?: number;
        classifyDefinitions?: boolean;
        timeBudgetMs?: number;
    }): FffResult<FffGrepResult>;
    destroy(): void;
};
type FffModule = {
    FileFinder: {
        create(options: {
            basePath: string;
            aiMode?: boolean;
        }): FffResult<FffFinder>;
    };
};
export type FffLoader = () => Promise<FffModule>;
export type FffSearchOptions = {
    worktree: string;
    enabled?: boolean;
    scanTimeoutMs?: number;
    loader?: FffLoader;
};
export type FffUnavailable = {
    ok: false;
    accelerated: false;
    reason: string;
};
export type NormalizedFileSearchItem = {
    path: string;
    fileName?: string;
    size?: number;
    modified?: number;
    gitStatus?: string;
    score?: number;
    matchType?: string;
    exactMatch?: boolean;
};
export type NormalizedFileSearchResult = FffUnavailable | {
    ok: true;
    accelerated: true;
    query: string;
    totalMatched: number;
    totalFiles: number;
    results: NormalizedFileSearchItem[];
};
export type NormalizedGlobResult = FffUnavailable | {
    ok: true;
    accelerated: true;
    pattern: string;
    totalMatched: number;
    totalFiles: number;
    files: NormalizedFileSearchItem[];
};
export type NormalizedGrepResult = FffUnavailable | {
    ok: true;
    accelerated: true;
    query: string;
    totalMatches: number;
    totalFilesSearched: number;
    totalFiles: number;
    filteredFileCount: number;
    hasMore: boolean;
    regexFallbackError?: string;
    results: Array<{
        file: string;
        matchLine: number;
        matchText: string;
        isDefinition?: boolean;
        context?: Array<{
            line: number;
            text: string;
        }>;
    }>;
};
export declare function fffFileSearch(options: FffSearchOptions, query: string, pageSize: number): Promise<NormalizedFileSearchResult>;
export declare function fffGlob(options: FffSearchOptions, pattern: string, pageSize: number): Promise<NormalizedGlobResult>;
export declare function fffGrep(options: FffSearchOptions, query: string, input?: {
    maxMatches?: number;
    contextLines?: number;
    mode?: "plain" | "regex" | "fuzzy";
}): Promise<NormalizedGrepResult>;
export declare function getFffAvailability(options: FffSearchOptions): Promise<{
    available: boolean;
    reason?: string;
}>;
export declare function clearFffSearchCache(): void;
export {};
//# sourceMappingURL=fff-search.d.ts.map