export type UseRAGOptions = {
    autoLoadStatus?: boolean;
    conversationId?: string;
    streamPath?: string;
};
export declare const useRAG: (path: string, options?: UseRAGOptions) => {
    chunkPreview: {
        clear: () => void;
        error: import("vue").Ref<string | null, string | null>;
        inspect: (id: string) => Promise<{
            ok: true;
        } & import("../..").RAGDocumentChunkPreview>;
        isLoading: import("vue").Ref<boolean, boolean>;
        preview: import("vue").Ref<{
            document: {
                source: string;
                id: string;
                kind?: string | undefined;
                title: string;
                format?: import("../..").RAGContentFormat | undefined;
                chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
                chunkSize?: number | undefined;
                chunkCount?: number | undefined;
                createdAt?: number | undefined;
                updatedAt?: number | undefined;
                metadata?: Record<string, unknown> | undefined;
            };
            normalizedText: string;
            chunks: {
                chunkId: string;
                text: string;
                title?: string | undefined;
                source?: string | undefined;
                metadata?: Record<string, unknown> | undefined;
                embedding?: number[] | undefined;
            }[];
        } | null, import("../..").RAGDocumentChunkPreview | {
            document: {
                source: string;
                id: string;
                kind?: string | undefined;
                title: string;
                format?: import("../..").RAGContentFormat | undefined;
                chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
                chunkSize?: number | undefined;
                chunkCount?: number | undefined;
                createdAt?: number | undefined;
                updatedAt?: number | undefined;
                metadata?: Record<string, unknown> | undefined;
            };
            normalizedText: string;
            chunks: {
                chunkId: string;
                text: string;
                title?: string | undefined;
                source?: string | undefined;
                metadata?: Record<string, unknown> | undefined;
                embedding?: number[] | undefined;
            }[];
        } | null>;
    };
    citations: {
        citations: import("vue").ComputedRef<import("../..").RAGCitation[]>;
        hasCitations: import("vue").ComputedRef<boolean>;
        sourceGroups: import("vue").ComputedRef<import("../..").RAGSourceGroup[]>;
    };
    documents: {
        documents: import("vue").Ref<{
            id: string;
            title: string;
            source: string;
            text?: string | undefined;
            kind?: string | undefined;
            format?: import("../..").RAGContentFormat | undefined;
            chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
            chunkSize?: number | undefined;
            chunkCount?: number | undefined;
            createdAt?: number | undefined;
            updatedAt?: number | undefined;
            metadata?: Record<string, unknown> | undefined;
        }[], import("../..").RAGIndexedDocument[] | {
            id: string;
            title: string;
            source: string;
            text?: string | undefined;
            kind?: string | undefined;
            format?: import("../..").RAGContentFormat | undefined;
            chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
            chunkSize?: number | undefined;
            chunkCount?: number | undefined;
            createdAt?: number | undefined;
            updatedAt?: number | undefined;
            metadata?: Record<string, unknown> | undefined;
        }[]>;
        error: import("vue").Ref<string | null, string | null>;
        isLoading: import("vue").Ref<boolean, boolean>;
        lastResponse: import("vue").Ref<{
            ok: true;
            documents: {
                id: string;
                title: string;
                source: string;
                text?: string | undefined;
                kind?: string | undefined;
                format?: import("../..").RAGContentFormat | undefined;
                chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
                chunkSize?: number | undefined;
                chunkCount?: number | undefined;
                createdAt?: number | undefined;
                updatedAt?: number | undefined;
                metadata?: Record<string, unknown> | undefined;
            }[];
            lastSeedMsByMode?: Record<string, number> | undefined;
        } | null, import("../..").RAGDocumentsResponse | {
            ok: true;
            documents: {
                id: string;
                title: string;
                source: string;
                text?: string | undefined;
                kind?: string | undefined;
                format?: import("../..").RAGContentFormat | undefined;
                chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
                chunkSize?: number | undefined;
                chunkCount?: number | undefined;
                createdAt?: number | undefined;
                updatedAt?: number | undefined;
                metadata?: Record<string, unknown> | undefined;
            }[];
            lastSeedMsByMode?: Record<string, number> | undefined;
        } | null>;
        load: (kind?: string) => Promise<import("../..").RAGDocumentsResponse>;
        reset: () => void;
    };
    index: {
        backends: import("vue").Ref<{
            ok: true;
            defaultMode?: string | undefined;
            activeModeCookie?: string | undefined;
            backends: {
                id: string;
                label: string;
                path?: string | undefined;
                available: boolean;
                reason?: string | undefined;
                lastSeedMs?: number | undefined;
                status?: {
                    backend: "in_memory" | "sqlite" | "postgres";
                    vectorMode: "in_memory" | "json_fallback" | "native_vec0" | "native_pgvector";
                    dimensions?: number | undefined;
                    native?: {
                        requested: boolean;
                        available: boolean;
                        active: boolean;
                        mode?: "vec0" | undefined;
                        tableName?: string | undefined;
                        distanceMetric?: "cosine" | "l2" | undefined;
                        resolution?: {
                            status: import("../..").SQLiteVecResolutionStatus;
                            source: import("../..").SQLiteVecResolutionSource;
                            platformKey: string;
                            packageName?: string | undefined;
                            packageVersion?: string | undefined;
                            packageRoot?: string | undefined;
                            libraryFile?: string | undefined;
                            libraryPath?: string | undefined;
                            reason?: string | undefined;
                        } | undefined;
                        fallbackReason?: string | undefined;
                        lastLoadError?: string | undefined;
                        lastQueryError?: string | undefined;
                        lastUpsertError?: string | undefined;
                    } | {
                        requested: boolean;
                        available: boolean;
                        active: boolean;
                        mode?: "pgvector" | undefined;
                        extensionName?: string | undefined;
                        schemaName?: string | undefined;
                        tableName?: string | undefined;
                        distanceMetric?: "cosine" | "l2" | "inner_product" | undefined;
                        indexType?: "none" | "hnsw" | "ivfflat" | undefined;
                        fallbackReason?: string | undefined;
                        lastInitError?: string | undefined;
                        lastQueryError?: string | undefined;
                        lastUpsertError?: string | undefined;
                        lastMigrationError?: string | undefined;
                    } | undefined;
                } | undefined;
                capabilities?: {
                    backend: "in_memory" | "sqlite" | "postgres" | "custom";
                    persistence: "memory_only" | "embedded" | "external";
                    nativeVectorSearch: boolean;
                    serverSideFiltering: boolean;
                    streamingIngestStatus: boolean;
                } | undefined;
            }[];
        } | null, import("../..").RAGBackendsResponse | {
            ok: true;
            defaultMode?: string | undefined;
            activeModeCookie?: string | undefined;
            backends: {
                id: string;
                label: string;
                path?: string | undefined;
                available: boolean;
                reason?: string | undefined;
                lastSeedMs?: number | undefined;
                status?: {
                    backend: "in_memory" | "sqlite" | "postgres";
                    vectorMode: "in_memory" | "json_fallback" | "native_vec0" | "native_pgvector";
                    dimensions?: number | undefined;
                    native?: {
                        requested: boolean;
                        available: boolean;
                        active: boolean;
                        mode?: "vec0" | undefined;
                        tableName?: string | undefined;
                        distanceMetric?: "cosine" | "l2" | undefined;
                        resolution?: {
                            status: import("../..").SQLiteVecResolutionStatus;
                            source: import("../..").SQLiteVecResolutionSource;
                            platformKey: string;
                            packageName?: string | undefined;
                            packageVersion?: string | undefined;
                            packageRoot?: string | undefined;
                            libraryFile?: string | undefined;
                            libraryPath?: string | undefined;
                            reason?: string | undefined;
                        } | undefined;
                        fallbackReason?: string | undefined;
                        lastLoadError?: string | undefined;
                        lastQueryError?: string | undefined;
                        lastUpsertError?: string | undefined;
                    } | {
                        requested: boolean;
                        available: boolean;
                        active: boolean;
                        mode?: "pgvector" | undefined;
                        extensionName?: string | undefined;
                        schemaName?: string | undefined;
                        tableName?: string | undefined;
                        distanceMetric?: "cosine" | "l2" | "inner_product" | undefined;
                        indexType?: "none" | "hnsw" | "ivfflat" | undefined;
                        fallbackReason?: string | undefined;
                        lastInitError?: string | undefined;
                        lastQueryError?: string | undefined;
                        lastUpsertError?: string | undefined;
                        lastMigrationError?: string | undefined;
                    } | undefined;
                } | undefined;
                capabilities?: {
                    backend: "in_memory" | "sqlite" | "postgres" | "custom";
                    persistence: "memory_only" | "embedded" | "external";
                    nativeVectorSearch: boolean;
                    serverSideFiltering: boolean;
                    streamingIngestStatus: boolean;
                } | undefined;
            }[];
        } | null>;
        clearIndex: () => Promise<{
            ok: boolean;
        }>;
        createDocument: (input: {
            id?: string;
            title?: string;
            source?: string;
            text: string;
            format?: import("../..").RAGContentFormat;
            metadata?: Record<string, unknown>;
            chunking?: {
                maxChunkLength?: number;
                chunkOverlap?: number;
                minChunkLength?: number;
                strategy?: import("../..").RAGChunkingStrategy;
            };
        }) => Promise<import("../..").RAGMutationResponse>;
        deleteDocument: (id: string) => Promise<import("../..").RAGMutationResponse>;
        error: import("vue").Ref<string | null, string | null>;
        isLoading: import("vue").Ref<boolean, boolean>;
        lastMutation: import("vue").Ref<{
            ok: boolean;
            error?: string | undefined;
            deleted?: string | undefined;
            inserted?: string | undefined;
            status?: string | undefined;
            documents?: number | undefined;
            backendStats?: Record<string, {
                chunkCount: number;
                totalDocuments: number;
                elapsedMs: number;
            }> | undefined;
            document?: {
                id: string;
                title: string;
                source: string;
                text?: string | undefined;
                kind?: string | undefined;
                format?: import("../..").RAGContentFormat | undefined;
                chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
                chunkSize?: number | undefined;
                chunkCount?: number | undefined;
                createdAt?: number | undefined;
                updatedAt?: number | undefined;
                metadata?: Record<string, unknown> | undefined;
            } | undefined;
        } | null, import("../..").RAGMutationResponse | {
            ok: boolean;
            error?: string | undefined;
            deleted?: string | undefined;
            inserted?: string | undefined;
            status?: string | undefined;
            documents?: number | undefined;
            backendStats?: Record<string, {
                chunkCount: number;
                totalDocuments: number;
                elapsedMs: number;
            }> | undefined;
            document?: {
                id: string;
                title: string;
                source: string;
                text?: string | undefined;
                kind?: string | undefined;
                format?: import("../..").RAGContentFormat | undefined;
                chunkStrategy?: import("../..").RAGChunkingStrategy | undefined;
                chunkSize?: number | undefined;
                chunkCount?: number | undefined;
                createdAt?: number | undefined;
                updatedAt?: number | undefined;
                metadata?: Record<string, unknown> | undefined;
            } | undefined;
        } | null>;
        loadBackends: () => Promise<import("../..").RAGBackendsResponse>;
        reseed: () => Promise<import("../..").RAGMutationResponse>;
        reset: () => Promise<import("../..").RAGMutationResponse>;
        resetState: () => void;
    };
    ingest: {
        clearIndex: () => Promise<{
            ok: boolean;
        }>;
        error: import("vue").Ref<string | null, string | null>;
        ingest: (chunks: import("../..").RAGDocumentChunk[]) => Promise<import("../..").RAGIngestResponse>;
        ingestChunks: (chunks: import("../..").RAGDocumentChunk[]) => Promise<import("../..").RAGIngestResponse>;
        ingestDocuments: (input: import("../..").RAGDocumentIngestInput) => Promise<import("../..").RAGIngestResponse>;
        isIngesting: import("vue").Ref<boolean, boolean>;
        lastDocumentCount: import("vue").Ref<number | null, number | null>;
        lastIngestCount: import("vue").Ref<number | null, number | null>;
        lastResponse: import("vue").Ref<{
            ok: boolean;
            count?: number | undefined;
            documentCount?: number | undefined;
            error?: string | undefined;
        } | null, import("../..").RAGIngestResponse | {
            ok: boolean;
            count?: number | undefined;
            documentCount?: number | undefined;
            error?: string | undefined;
        } | null>;
        reset: () => void;
    };
    search: {
        error: import("vue").Ref<string | null, string | null>;
        hasSearched: import("vue").Ref<boolean, boolean>;
        isSearching: import("vue").Ref<boolean, boolean>;
        lastRequest: import("vue").Ref<{
            filter?: Record<string, unknown> | undefined;
            query: string;
            topK?: number | undefined;
            scoreThreshold?: number | undefined;
            model?: string | undefined;
        } | null, import("../..").RAGSearchRequest | {
            filter?: Record<string, unknown> | undefined;
            query: string;
            topK?: number | undefined;
            scoreThreshold?: number | undefined;
            model?: string | undefined;
        } | null>;
        reset: () => void;
        results: import("vue").Ref<{
            chunkId: string;
            score: number;
            text: string;
            title?: string | undefined;
            source?: string | undefined;
            metadata?: Record<string, unknown> | undefined;
        }[], import("../..").RAGSource[] | {
            chunkId: string;
            score: number;
            text: string;
            title?: string | undefined;
            source?: string | undefined;
            metadata?: Record<string, unknown> | undefined;
        }[]>;
        search: (input: import("../..").RAGSearchRequest) => Promise<import("../..").RAGSource[]>;
    };
    sources: {
        hasSources: import("vue").ComputedRef<boolean>;
        latestAssistantMessage: import("vue").ComputedRef<import("../..").AIMessage | undefined>;
        sourceGroups: import("vue").ComputedRef<import("../..").RAGSourceGroup[]>;
        sources: import("vue").ComputedRef<import("../..").RAGSource[]>;
    };
    status: {
        capabilities: import("vue").Ref<import("../..").RAGBackendCapabilities | undefined, import("../..").RAGBackendCapabilities | undefined>;
        error: import("vue").Ref<string | null, string | null>;
        isLoading: import("vue").Ref<boolean, boolean>;
        refresh: () => Promise<import("../..").RAGStatusResponse>;
        reset: () => void;
        status: import("vue").Ref<import("../..").RAGVectorStoreStatus | undefined, import("../..").RAGVectorStoreStatus | undefined>;
    };
    stream: {
        citations: import("vue").ComputedRef<import("../..").RAGCitation[]>;
        hasRetrieved: import("vue").ComputedRef<boolean>;
        hasSources: import("vue").ComputedRef<boolean>;
        isAnswerStreaming: import("vue").ComputedRef<boolean>;
        isComplete: import("vue").ComputedRef<boolean>;
        isRetrieving: import("vue").ComputedRef<boolean>;
        latestAssistantMessage: import("vue").ComputedRef<import("../..").AIMessage | undefined>;
        query: (content: string, attachments?: import("../..").AIAttachment[]) => void;
        retrieval: import("vue").ComputedRef<import("../..").RAGRetrievedState | null>;
        sourceGroups: import("vue").ComputedRef<import("../..").RAGSourceGroup[]>;
        sources: import("vue").ComputedRef<import("../..").RAGSource[]>;
        stage: import("vue").ComputedRef<import("../..").RAGStreamStage>;
        branch: (messageId: string, content: string) => void;
        cancel: () => void;
        destroy: () => void;
        error: import("vue").Ref<string | null, string | null>;
        isStreaming: import("vue").Ref<boolean, boolean>;
        messages: import("vue").ShallowRef<import("../..").AIMessage[], import("../..").AIMessage[]>;
        send: (content: string, attachments?: import("../..").AIAttachment[]) => void;
    };
};
export type UseRAGResult = ReturnType<typeof useRAG>;
