import * as React$1 from 'react';
import React__default, { ReactNode } from 'react';

type ClassValue = string | number | boolean | undefined | null | {
    [key: string]: any;
} | ClassValue[];
declare function cn(...inputs: ClassValue[]): string;

interface User {
    id: string;
    email: string;
    name: string;
    avatar_url?: string;
    role: "customer" | "front_agent" | "creator";
    created_at: string;
    updated_at: string;
}
interface SectionConfig {
    id: string;
    section_name: string;
    is_active: boolean;
    style_config: Record<string, unknown>;
    order_index: number;
}
interface UserConsent {
    privacy_policy_agreed: boolean;
    terms_agreed: boolean;
    marketing_agreed: boolean;
    agreed_at: string;
}
interface BaseComponentProps {
    className?: string;
    children?: React.ReactNode;
}
interface AuthConfig {
    supabaseUrl?: string;
    supabaseAnonKey?: string;
    nextAuthConfig?: Record<string, unknown>;
}
interface HeroSectionProps extends BaseComponentProps {
    title?: string;
    subtitle?: string;
    ctaText?: string;
    backgroundImage?: string;
    onCtaClick?: () => void;
    ctaHref?: string;
    ctaTarget?: "_self" | "_blank";
}
interface FeaturesSectionProps extends BaseComponentProps {
    features?: Array<{
        title: string;
        description: string;
        icon?: React.ReactNode;
    }>;
}
interface CTASectionProps extends BaseComponentProps {
    title?: string;
    subtitle?: string;
    buttonText?: string;
    variant?: "primary" | "secondary";
    onButtonClick?: () => void;
}
interface ProblemSectionProps extends BaseComponentProps {
    title?: string;
    subtitle?: string;
    problems?: Array<{
        title: string;
        description: string;
        icon?: React.ReactNode;
    }>;
    variant?: "grid" | "list";
}
interface TestimonialSectionProps extends BaseComponentProps {
    title?: string;
    subtitle?: string;
    testimonials?: Array<{
        content: string;
        author: string;
        role?: string;
        company?: string;
        avatar?: string;
        rating?: number;
    }>;
    variant?: "cards" | "carousel" | "grid";
}
interface PricingSectionProps extends BaseComponentProps {
    title?: string;
    subtitle?: string;
    plans?: Array<{
        name: string;
        price: string;
        period?: string;
        description: string;
        features: string[];
        highlighted?: boolean;
        buttonText?: string;
        buttonVariant?: "primary" | "secondary" | "outline";
        onButtonClick?: () => void;
    }>;
    billingOptions?: Array<{
        label: string;
        value: string;
    }>;
    selectedBilling?: string;
    onBillingChange?: (value: string) => void;
}
interface FAQSectionProps extends BaseComponentProps {
    title?: string;
    subtitle?: string;
    faqs?: Array<{
        question: string;
        answer: string;
    }>;
    variant?: "accordion" | "grid";
}

interface Message {
    id: string;
    content: string;
    sender: "user" | "ai";
    timestamp: Date;
    type?: "text" | "error" | "system";
}
interface AgentConfig$1 {
    name: string;
    description: string;
    greeting: string;
    personality: string;
    updatedAt: string;
}
declare const FloatingChatButton: ({ theme, position, size, customStyles, apiEndpoint, initialMessage, }: {
    theme?: string;
    position?: string;
    size?: string;
    customStyles: any;
    apiEndpoint?: string;
    initialMessage?: string;
}) => React$1.JSX.Element;

interface MobileFullscreenChatProps {
    isOpen: boolean;
    onClose: () => void;
    theme?: "light" | "dark";
    apiEndpoint?: string;
    initialMessage?: string;
}
declare const MobileFullscreenChat: React.FC<MobileFullscreenChatProps>;

interface RAGAdminIntegratedProps {
    title?: string;
    subtitle?: string;
    showNavigation?: boolean;
    defaultTab?: string;
    className?: string;
}
declare function RAGAdminIntegrated({ title, subtitle, showNavigation, defaultTab, className, }: RAGAdminIntegratedProps): React__default.JSX.Element;

interface Document {
    id: string;
    content: string;
    metadata: DocumentMetadata;
    source: string;
    chunks?: DocumentChunk[];
}
interface DocumentMetadata {
    title?: string;
    author?: string;
    createdAt: Date;
    updatedAt: Date;
    fileType: string;
    fileSize: number;
    language?: string;
    tags?: string[];
    categories?: string[];
    description?: string;
}
interface DocumentChunk {
    id: string;
    content: string;
    metadata: ChunkMetadata;
    embedding?: number[];
}
interface ChunkMetadata {
    documentId: string;
    chunkIndex: number;
    startOffset: number;
    endOffset: number;
    tokens: number;
    source: string;
}
interface SearchResult {
    chunk: DocumentChunk;
    score: number;
    document: Document;
}
interface EmbeddingModel {
    embed(text: string): Promise<number[]>;
    embedBatch(texts: string[]): Promise<number[][]>;
}
interface VectorStore {
    addDocuments(documents: Document[]): Promise<void>;
    search(query: string, k?: number): Promise<SearchResult[]>;
    delete(documentId: string): Promise<void>;
    update(document: Document): Promise<void>;
}
interface RAGConfig {
    embeddingModel: string;
    chunkSize: number;
    chunkOverlap: number;
    vectorStorePath: string;
    supabaseConfig: {
        url: string;
        anonKey: string;
        bucket: string;
    };
    llmConfig: {
        modelName: string;
        temperature: number;
        maxTokens: number;
        apiKey: string;
    };
}
interface ChatMessage {
    id: string;
    role: "user" | "assistant" | "system";
    content: string;
    timestamp: Date;
    updatedAt?: Date;
    metadata?: {
        sources?: SearchResult[];
        model?: string;
        tokenCount?: number;
        error?: string;
        [key: string]: any;
    };
}
interface ConversationContext {
    id: string;
    messages: ChatMessage[];
    sessionId?: string;
    userId?: string;
    createdAt: Date;
    updatedAt: Date;
    metadata?: Record<string, any>;
}

interface SupabaseStorageConfig {
    url: string;
    anonKey: string;
    bucket: string;
}
interface DocumentUploadResult {
    id: string;
    path: string;
    url: string;
    size: number;
    mimeType: string;
    uploadedAt: Date;
}
interface DocumentVersion {
    id: string;
    documentId: string;
    version: number;
    path: string;
    size: number;
    uploadedAt: Date;
    metadata?: Record<string, any>;
}
declare class SupabaseStorageManager {
    private client;
    private bucket;
    constructor(config: SupabaseStorageConfig);
    initializeBucket(): Promise<void>;
    uploadDocument(file: Buffer | File, fileName: string, metadata?: Record<string, any>): Promise<DocumentUploadResult>;
    downloadDocument(path: string): Promise<Buffer>;
    deleteDocument(path: string): Promise<void>;
    listDocuments(prefix?: string): Promise<Array<{
        name: string;
        id: string;
        updated_at: string;
        size: number;
        metadata: Record<string, any>;
    }>>;
    createDocumentVersion(originalPath: string, newFile: Buffer | File, version: number, metadata?: Record<string, any>): Promise<DocumentVersion>;
    getDocumentVersions(documentId: string): Promise<DocumentVersion[]>;
    private sanitizeFileName;
    private generateDocumentId;
    private getMimeType;
    getStorageStats(): Promise<{
        totalFiles: number;
        totalSize: number;
        bucketName: string;
    }>;
}

interface QueryProcessingConfig {
    enableSpellCheck?: boolean;
    enableSynonymExpansion?: boolean;
    enableStopWordRemoval?: boolean;
    minQueryLength?: number;
    maxQueryLength?: number;
}
interface ProcessedQuery {
    original: string;
    processed: string;
    keywords: string[];
    entities?: string[];
    intent?: string;
    language?: string;
}
declare class QueryProcessor {
    private config;
    private stopWords;
    private synonyms;
    constructor(config?: QueryProcessingConfig);
    processQuery(query: string): Promise<ProcessedQuery>;
    private isValidQuery;
    private normalizeText;
    private removeStopWords;
    private extractKeywords;
    private expandWithSynonyms;
    private detectLanguage;
    private extractEntities;
    private determineIntent;
    private initializeStopWords;
    private initializeSynonyms;
    addSynonyms(word: string, synonyms: string[]): void;
    addStopWords(words: string[]): void;
}

interface HybridSearchConfig {
    vectorWeight: number;
    keywordWeight: number;
    maxResults: number;
    minScore: number;
    enableReranking?: boolean;
}
interface KeywordSearchResult {
    chunkId: string;
    score: number;
    matches: string[];
}
declare class HybridRetriever {
    private vectorStore;
    private embeddingModel;
    private queryProcessor;
    private config;
    private documentIndex;
    constructor(vectorStore: VectorStore, embeddingModel: EmbeddingModel, config?: Partial<HybridSearchConfig>);
    search(query: string, k?: number): Promise<SearchResult[]>;
    private performVectorSearch;
    private performKeywordSearch;
    private combineResults;
    private rerankResults;
    updateDocumentIndex(chunkId: string, content: string): void;
    removeFromIndex(chunkId: string): void;
    updateConfig(config: Partial<HybridSearchConfig>): void;
    getSearchStats(): {
        indexSize: number;
        config: HybridSearchConfig;
    };
    clearIndex(): void;
}

declare class RAGEngine {
    private vectorStore;
    private embeddingModel;
    private processingPipeline;
    private storageManager?;
    private hybridRetriever?;
    private rssManager;
    private config;
    constructor(config: RAGConfig);
    private initializeComponents;
    initialize(): Promise<void>;
    addDocument(filePath: string, content: Buffer): Promise<string>;
    addDocuments(files: Array<{
        path: string;
        content: Buffer;
    }>): Promise<string[]>;
    search(query: string, k?: number): Promise<SearchResult[]>;
    vectorSearch(query: string, k?: number): Promise<SearchResult[]>;
    hybridSearch(query: string, k?: number): Promise<SearchResult[]>;
    deleteDocument(documentId: string): Promise<void>;
    updateDocument(documentId: string, filePath: string, content: Buffer): Promise<void>;
    getSupportedExtensions(): string[];
    getStats(): Promise<{
        documentCount: number;
        chunkCount: number;
        embeddingModel: string;
        vectorStoreType: string;
    }>;
    clear(): Promise<void>;
    uploadDocumentToStorage(file: Buffer | File, fileName: string, metadata?: Record<string, any>): Promise<DocumentUploadResult>;
    addDocumentFromStorage(filePath: string): Promise<string>;
    uploadAndAddDocument(file: Buffer | File, fileName: string, metadata?: Record<string, any>): Promise<{
        documentId: string;
        uploadResult: DocumentUploadResult;
    }>;
    deleteDocumentFromStorage(documentPath: string): Promise<void>;
    listStorageDocuments(): Promise<Array<{
        name: string;
        id: string;
        updated_at: string;
        size: number;
        metadata: Record<string, any>;
    }>>;
    getStorageStats(): Promise<{
        totalFiles: number;
        totalSize: number;
        bucketName: string;
    }>;
    private getDocumentIdFromPath;
    isStorageConfigured(): boolean;
    updateHybridSearchConfig(config: Partial<HybridSearchConfig>): void;
    getSearchStats(): {
        hybridRetriever?: {
            indexSize: number;
            config: HybridSearchConfig;
        };
        vectorStore: {
            chunkCount: number;
            embeddingModel: string;
        };
    };
    clearSearchIndex(): void;
    addSearchSynonyms(word: string, synonyms: string[]): void;
    searchWithOptions(query: string, options?: {
        method?: "hybrid" | "vector" | "keyword";
        k?: number;
        minScore?: number;
        vectorWeight?: number;
        keywordWeight?: number;
    }): Promise<SearchResult[]>;
    addNaverBlogRSS(blogId: string, feedName?: string, config?: {
        maxItems?: number;
        includeContent?: boolean;
    }): Promise<{
        documentIds: string[];
        feedName: string;
        itemCount: number;
    }>;
    addRSSFeed(url: string, feedName?: string, config?: {
        maxItems?: number;
        includeContent?: boolean;
    }): Promise<{
        documentIds: string[];
        feedName: string;
        itemCount: number;
    }>;
    refreshRSSFeed(feedName: string): Promise<{
        documentIds: string[];
        itemCount: number;
    }>;
    refreshAllRSSFeeds(): Promise<Map<string, {
        documentIds: string[];
        itemCount: number;
    }>>;
    removeRSSFeed(feedName: string): boolean;
    getRSSFeedNames(): string[];
    getRSSFeedInfo(feedName: string): {
        exists: boolean;
        type: "naver" | "generic" | null;
        blogId?: string;
        rssUrl?: string;
    };
    static extractNaverBlogId(url: string): string | null;
}

interface TextSplitterConfig {
    chunkSize: number;
    chunkOverlap: number;
    separators?: string[];
    keepSeparator?: boolean;
}
declare class RecursiveTextSplitter {
    private config;
    constructor(config: TextSplitterConfig);
    splitDocument(document: Document): Promise<DocumentChunk[]>;
    private splitText;
    private estimateTokenCount;
}

interface ProcessingPipelineConfig {
    textSplitter: TextSplitterConfig;
    enableMetadataExtraction?: boolean;
    enableTextCleaning?: boolean;
}
declare class DocumentProcessingPipeline {
    private loaderFactory;
    private textSplitter;
    private config;
    constructor(config: ProcessingPipelineConfig);
    processDocument(filePath: string, content: Buffer): Promise<Document>;
    processBatch(files: Array<{
        path: string;
        content: Buffer;
    }>): Promise<Document[]>;
    getSupportedExtensions(): string[];
    private extractMetadata;
    private cleanDocumentText;
    private detectLanguage;
    private extractDescription;
    private extractCategories;
}

declare class DocumentLoaderFactory {
    private supportedExtensions;
    loadDocument(filePath: string, content: Buffer): Promise<Document>;
    private loadPDFWithLangChain;
    private loadTextFile;
    private convertToOurFormat;
    private createTempFile;
    private cleanupTempFile;
    private getFileExtension;
    private extractTitleFromPath;
    private generateDocumentId;
    private detectLanguage;
    private extractDescription;
    getSupportedExtensions(): string[];
    isSupported(filePath: string): boolean;
}

declare abstract class BaseDocumentLoader {
    abstract supportedExtensions: string[];
    abstract load(filePath: string, content: Buffer): Promise<Document>;
    canLoad(fileExtension: string): boolean;
    protected generateDocumentId(filePath: string): string;
    protected createBaseMetadata(filePath: string, fileSize: number): DocumentMetadata;
    protected cleanText(text: string): string;
}

declare class TextDocumentLoader extends BaseDocumentLoader {
    supportedExtensions: string[];
    load(filePath: string, content: Buffer): Promise<Document>;
}

declare class PDFDocumentLoader extends BaseDocumentLoader {
    supportedExtensions: string[];
    load(filePath: string, content: Buffer): Promise<Document>;
    private extractWithPDFJS;
    private extractWithPDFParse;
    private extractBasicText;
    private extractTitleFromFilename;
    private extractDescription;
}

declare class DocxDocumentLoader extends BaseDocumentLoader {
    supportedExtensions: string[];
    load(filePath: string, content: Buffer): Promise<Document>;
}

interface RSSLoaderConfig {
    maxItems?: number;
    includeContent?: boolean;
    requestOptions?: {
        timeout?: number;
        headers?: Record<string, string>;
    };
}
interface RSSItem {
    title?: string;
    link?: string;
    content?: string;
    contentSnippet?: string;
    author?: string;
    pubDate?: string;
    categories?: string[];
    guid?: string;
}
interface RSSFeed {
    title?: string;
    description?: string;
    link?: string;
    language?: string;
    lastBuildDate?: string;
    items: RSSItem[];
}
declare class RSSLoader extends BaseDocumentLoader {
    supportedExtensions: string[];
    private parser;
    private config;
    constructor(config?: RSSLoaderConfig);
    load(filePath: string, content: Buffer): Promise<Document>;
    loadFromURL(url: string): Promise<Document[]>;
    loadFromString(rssContent: string, sourceUrl: string): Promise<Document[]>;
    private processFeed;
    private createDocumentFromItem;
    private cleanHtmlContent;
    private detectLanguage;
    protected generateDocumentId(identifier: string): string;
}
declare class NaverBlogRSSLoader extends RSSLoader {
    private blogId;
    constructor(blogId: string, config?: RSSLoaderConfig);
    loadBlog(): Promise<Document[]>;
    getBlogId(): string;
    getRSSUrl(): string;
    static createFromUrl(url: string, config?: RSSLoaderConfig): NaverBlogRSSLoader;
    static extractBlogId(url: string): string | null;
}
declare class RSSFeedManager {
    private feedSources;
    addFeed(name: string, loader: RSSLoader): void;
    removeFeed(name: string): boolean;
    loadAllFeeds(): Promise<Map<string, Document[]>>;
    getFeedNames(): string[];
    getFeed(name: string): RSSLoader | undefined;
}

declare class OpenAIEmbeddingModel implements EmbeddingModel {
    private embeddings;
    constructor(apiKey: string, modelName?: string);
    embed(text: string): Promise<number[]>;
    embedBatch(texts: string[]): Promise<number[][]>;
    getDimensions(): number;
}

type EmbeddingModelType = "openai" | "huggingface" | "local";
interface EmbeddingConfig {
    type: EmbeddingModelType;
    apiKey?: string;
    modelName?: string;
    baseUrl?: string;
}
declare class EmbeddingFactory {
    static create(config: EmbeddingConfig): EmbeddingModel;
}

declare class MemoryVectorStore implements VectorStore {
    private vectors;
    private embeddingModel;
    private storePath;
    constructor(embeddingModel: EmbeddingModel, storePath?: string);
    initialize(): Promise<void>;
    addDocuments(documents: Document[]): Promise<void>;
    search(query: string, k?: number): Promise<SearchResult[]>;
    delete(documentId: string): Promise<void>;
    update(document: Document): Promise<void>;
    clear(): Promise<void>;
    getCount(): number;
    private cosineSimilarity;
    private saveVectors;
    private loadVectors;
}

type VectorStoreType = "memory" | "supabase" | "pinecone";
declare class VectorStoreFactory {
    static create(type: VectorStoreType, embeddingModel: EmbeddingModel, config: any): VectorStore;
}

interface ConversationConfig {
    maxMessages: number;
    maxTokens?: number;
    retainSystemMessages: boolean;
    contextTimeoutMs?: number;
}
interface MessageSummary {
    totalMessages: number;
    userMessages: number;
    assistantMessages: number;
    systemMessages: number;
    totalTokens: number;
}
declare class ConversationContextManager {
    private conversations;
    private config;
    constructor(config?: Partial<ConversationConfig>);
    createConversation(id: string, systemPrompt?: string): ConversationContext;
    getConversation(id: string): ConversationContext | null;
    addMessage(conversationId: string, message: Omit<ChatMessage, "id" | "timestamp">): ChatMessage;
    updateMessage(conversationId: string, messageId: string, updates: Partial<ChatMessage>): boolean;
    getConversationHistory(conversationId: string, lastN?: number): ChatMessage[];
    getConversationSummary(conversationId: string): MessageSummary | null;
    clearConversation(conversationId: string): boolean;
    getAllConversations(): ConversationContext[];
    cleanupExpiredConversations(): number;
    private trimConversation;
    private generateMessageId;
    updateConversationMetadata(conversationId: string, metadata: Record<string, any>): boolean;
    getManagerStats(): {
        totalConversations: number;
        totalMessages: number;
        config: ConversationConfig;
    };
}

interface PromptTemplate {
    id: string;
    name: string;
    template: string;
    variables: string[];
    description?: string;
    language?: string;
}
interface PromptContext {
    query: string;
    retrievedDocuments: SearchResult[];
    conversationHistory: ChatMessage[];
    userContext?: Record<string, any>;
    language?: string;
}
declare class PromptManager {
    private templates;
    constructor();
    private initializeDefaultTemplates;
    addTemplate(template: PromptTemplate): void;
    getTemplate(id: string): PromptTemplate | null;
    listTemplates(): PromptTemplate[];
    buildPrompt(templateId: string, context: PromptContext): string;
    private formatContext;
    private formatConversationHistory;
    getTemplateByLanguage(baseId: string, language: string): PromptTemplate | null;
    validateTemplate(template: PromptTemplate): {
        isValid: boolean;
        missingVariables: string[];
    };
    createCustomTemplate(id: string, name: string, template: string, options?: {
        description?: string;
        language?: string;
        variables?: string[];
    }): PromptTemplate;
    removeTemplate(id: string): boolean;
    getTemplateStats(): {
        totalTemplates: number;
        languageBreakdown: Record<string, number>;
        averageVariables: number;
    };
}

interface ChatbotConfig$1 {
    ragEngine: RAGEngine;
    llmConfig: {
        apiKey: string;
        modelName: string;
        temperature?: number;
        maxTokens?: number;
        baseURL?: string;
    };
    conversationConfig?: Partial<ConversationConfig>;
    defaultPromptTemplate?: string;
    retrievalConfig?: {
        topK: number;
        minScore: number;
        searchMethod: "hybrid" | "vector" | "keyword";
    };
    languageDetection?: boolean;
}
interface ChatResponse {
    message: ChatMessage;
    sources: SearchResult[];
    conversationId: string;
    metadata: {
        retrievalTime: number;
        generationTime: number;
        totalTokens?: number;
        model: string;
        template: string;
    };
}
interface ChatRequest {
    message: string;
    conversationId?: string;
    systemPrompt?: string;
    promptTemplate?: string;
    retrievalOptions?: {
        topK?: number;
        minScore?: number;
        searchMethod?: "hybrid" | "vector" | "keyword";
    };
    userContext?: Record<string, any>;
}
declare class RAGChatbot {
    private ragEngine;
    private contextManager;
    private promptManager;
    private config;
    constructor(config: ChatbotConfig$1);
    chat(request: ChatRequest): Promise<ChatResponse>;
    private retrieveDocuments;
    private generateResponse;
    private callLLM;
    private detectLanguage;
    getConversation(conversationId: string): ConversationContext | null;
    clearConversation(conversationId: string): boolean;
    getConversationHistory(conversationId: string, lastN?: number): ChatMessage[];
    streamChat(request: ChatRequest): AsyncGenerator<{
        type: "retrieval" | "generation" | "complete";
        data: any;
    }>;
    private generateConversationId;
    private generateMessageId;
    updateConfig(updates: Partial<ChatbotConfig$1>): void;
    addPromptTemplate(template: {
        id: string;
        name: string;
        template: string;
        variables: string[];
        description?: string;
        language?: string;
    }): void;
    getStats(): {
        conversations: number;
        totalMessages: number;
        ragEngineStats: any;
        promptTemplates: number;
    };
    summarizeConversation(conversationId: string): Promise<string>;
    suggestFollowUpQuestions(conversationId: string): Promise<string[]>;
}

declare function createRAGChatbot(config: {
    ragEngine: any;
    llmConfig: {
        apiKey: string;
        modelName: string;
        temperature?: number;
        maxTokens?: number;
    };
    options?: {
        defaultPromptTemplate?: string;
        languageDetection?: boolean;
        retrievalConfig?: {
            topK?: number;
            minScore?: number;
            searchMethod?: "hybrid" | "vector" | "keyword";
        };
    };
}): RAGChatbot;

declare function createDefaultRAGConfig(llmApiKey: string, vectorStorePath?: string, chunkSize?: number, chunkOverlap?: number): {
    embeddingModel: string;
    chunkSize: number;
    chunkOverlap: number;
    vectorStorePath: string;
    supabaseConfig: {
        url: string;
        anonKey: string;
        bucket: string;
    };
    llmConfig: {
        modelName: string;
        temperature: number;
        maxTokens: number;
        apiKey: string;
    };
};

interface KnowledgeManagementProps {
    ragConfig?: RAGConfig;
}
declare function KnowledgeManagement({ ragConfig }: KnowledgeManagementProps): React__default.JSX.Element;

interface KnowledgeEntry {
    id: string;
    title: string;
    content: string;
    category: string;
    tags: string[];
    createdAt: string;
    updatedAt: string;
    status: "active" | "draft" | "archived";
    description?: string;
    priority?: "high" | "medium" | "low";
}
interface KnowledgeEditorProps {
    ragEngine: RAGEngine;
    onEntryCreated?: (entry: KnowledgeEntry) => void;
    onEntryUpdated?: (entry: KnowledgeEntry) => void;
    onEntryDeleted?: (entryId: string) => void;
}
declare function KnowledgeEditor({ ragEngine, onEntryCreated, onEntryUpdated, onEntryDeleted, }: KnowledgeEditorProps): React$1.JSX.Element;

interface DocumentUploaderProps {
    ragEngine?: RAGEngine;
    onDocumentUploaded?: (document: any) => void;
    onDocumentDeleted?: (documentId: string) => void;
}
declare function DocumentUploader({ ragEngine, onDocumentUploaded, onDocumentDeleted, }: DocumentUploaderProps): React__default.JSX.Element;

interface RAGManagerProps {
    ragEngine: RAGEngine;
    onRetrainTriggered?: () => void;
}
declare function RAGManager({ ragEngine, onRetrainTriggered }: RAGManagerProps): React__default.JSX.Element;

interface RSSFeedInfo {
    name: string;
    type: "naver" | "generic";
    url?: string;
    blogId?: string;
    itemCount?: number;
    lastUpdated?: Date;
}
interface RSSManagerProps {
    ragEngine?: any;
    onFeedAdded?: (feedInfo: RSSFeedInfo) => void;
    onFeedRemoved?: (feedName: string) => void;
    onFeedRefreshed?: (feedName: string, itemCount: number) => void;
}
declare function RSSManager({ ragEngine, onFeedAdded, onFeedRemoved, onFeedRefreshed, }: RSSManagerProps): React__default.JSX.Element;

interface QAItem {
    question: string;
    answer: string;
    category: string;
    tags: string;
}
interface QALearningManagerProps {
    onQALearned?: (qaItems: QAItem[]) => void;
}
declare function QALearningManager({ onQALearned }: QALearningManagerProps): React__default.JSX.Element;

interface AgentConfig {
    name: string;
    description: string;
    greeting: string;
    personality: string;
}
interface AgentConfigManagerProps {
    onConfigSaved?: (config: AgentConfig) => void;
}
declare function AgentConfigManager({ onConfigSaved }: AgentConfigManagerProps): React__default.JSX.Element;

interface ChatbotConfig {
    systemPrompt: string;
    welcomeMessage: string;
    suggestedQuestions: string[];
    maxConversationHistory: number;
    enableRAG: boolean;
    ragSettings: {
        similarityThreshold: number;
        maxRetrievedDocs: number;
        chunkSize: number;
        chunkOverlap: number;
    };
    uiSettings: {
        theme: string;
        language: string;
        showTimestamps: boolean;
        enableTypingIndicator: boolean;
    };
}
interface ChatbotProviderProps {
    children: ReactNode;
    initialConfig?: Partial<ChatbotConfig>;
    autoInitialize?: boolean;
}
declare function ChatbotProvider({ children, initialConfig, autoInitialize, }: ChatbotProviderProps): React__default.JSX.Element;

declare function ChunkManager(): React__default.JSX.Element;

export { AgentConfigManager, BaseDocumentLoader, ChatbotProvider, ChunkManager, ConversationContextManager, DocumentLoaderFactory, DocumentProcessingPipeline, DocumentUploader, DocxDocumentLoader, EmbeddingFactory, FloatingChatButton, HybridRetriever, KnowledgeEditor, KnowledgeManagement, MemoryVectorStore, MobileFullscreenChat, NaverBlogRSSLoader, OpenAIEmbeddingModel, PDFDocumentLoader, PromptManager, QALearningManager, QueryProcessor, RAGAdminIntegrated, RAGChatbot, RAGEngine, RAGManager, RSSFeedManager, RSSLoader, RSSManager, RecursiveTextSplitter, SupabaseStorageManager, TextDocumentLoader, VectorStoreFactory, cn, createDefaultRAGConfig, createRAGChatbot };
export type { AgentConfig$1 as AgentConfig, AuthConfig, BaseComponentProps, CTASectionProps, ChatMessage, ChatRequest, ChatResponse, ChatbotConfig$1 as ChatbotConfig, ChunkMetadata, ConversationConfig, ConversationContext, Document, DocumentChunk, DocumentMetadata, DocumentUploadResult, DocumentVersion, EmbeddingConfig, EmbeddingModel, EmbeddingModelType, FAQSectionProps, FeaturesSectionProps, HeroSectionProps, HybridSearchConfig, KeywordSearchResult, Message, MessageSummary, PricingSectionProps, ProblemSectionProps, ProcessedQuery, ProcessingPipelineConfig, PromptContext, PromptTemplate, QueryProcessingConfig, RAGConfig, RSSFeed, RSSItem, RSSLoaderConfig, SearchResult, SectionConfig, SupabaseStorageConfig, TestimonialSectionProps, TextSplitterConfig, User, UserConsent, VectorStore, VectorStoreType };