@djangocfg/ext-knowbase 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,4404 @@
+import { ConsolaInstance } from 'consola';
+import * as _djangocfg_ext_base from '@djangocfg/ext-base';
+import { z, ZodError } from 'zod';
+
+/**
+ * Content classification
+ * * `document` - Document
+ * * `code` - Code
+ * * `image` - Image
+ * * `data` - Data
+ * * `archive` - Archive
+ * * `unknown` - Unknown
+ */
+declare enum ArchiveItemContentType {
+    DOCUMENT = "document",
+    CODE = "code",
+    IMAGE = "image",
+    DATA = "data",
+    ARCHIVE = "archive",
+    UNKNOWN = "unknown"
+}
+/**
+ * Type of content in chunk
+ * * `text` - Text
+ * * `code` - Code
+ * * `heading` - Heading
+ * * `metadata` - Metadata
+ * * `table` - Table
+ * * `list` - List
+ */
+declare enum ArchiveItemChunkChunkType {
+    TEXT = "text",
+    CODE = "code",
+    HEADING = "heading",
+    METADATA = "metadata",
+    TABLE = "table",
+    LIST = "list"
+}
+/**
+ * Type of content in chunk
+ * * `text` - Text
+ * * `code` - Code
+ * * `heading` - Heading
+ * * `metadata` - Metadata
+ * * `table` - Table
+ * * `list` - List
+ */
+declare enum ArchiveItemChunkDetailChunkType {
+    TEXT = "text",
+    CODE = "code",
+    HEADING = "heading",
+    METADATA = "metadata",
+    TABLE = "table",
+    LIST = "list"
+}
+/**
+ * Type of content in chunk
+ * * `text` - Text
+ * * `code` - Code
+ * * `heading` - Heading
+ * * `metadata` - Metadata
+ * * `table` - Table
+ * * `list` - List
+ */
+declare enum ArchiveItemChunkRequestChunkType {
+    TEXT = "text",
+    CODE = "code",
+    HEADING = "heading",
+    METADATA = "metadata",
+    TABLE = "table",
+    LIST = "list"
+}
+/**
+ * Content classification
+ * * `document` - Document
+ * * `code` - Code
+ * * `image` - Image
+ * * `data` - Data
+ * * `archive` - Archive
+ * * `unknown` - Unknown
+ */
+declare enum ArchiveItemDetailContentType {
+    DOCUMENT = "document",
+    CODE = "code",
+    IMAGE = "image",
+    DATA = "data",
+    ARCHIVE = "archive",
+    UNKNOWN = "unknown"
+}
+/**
+ * * `document` - Document
+ * * `code` - Code
+ * * `image` - Image
+ * * `data` - Data
+ * * `archive` - Archive
+ * * `unknown` - Unknown
+ */
+declare enum ArchiveSearchRequestRequestContentTypesItems {
+    DOCUMENT = "document",
+    CODE = "code",
+    IMAGE = "image",
+    DATA = "data",
+    ARCHIVE = "archive",
+    UNKNOWN = "unknown"
+}
+/**
+ * * `text` - Text
+ * * `code` - Code
+ * * `heading` - Heading
+ * * `metadata` - Metadata
+ * * `table` - Table
+ * * `list` - List
+ */
+declare enum ArchiveSearchRequestRequestChunkTypesItems {
+    TEXT = "text",
+    CODE = "code",
+    HEADING = "heading",
+    METADATA = "metadata",
+    TABLE = "table",
+    LIST = "list"
+}
+/**
+ * Message sender role
+ * * `user` - User
+ * * `assistant` - Assistant
+ * * `system` - System
+ */
+declare enum ChatMessageRole {
+    USER = "user",
+    ASSISTANT = "assistant",
+    SYSTEM = "system"
+}
+/**
+ * Archive format
+ * * `zip` - ZIP
+ * * `tar` - TAR
+ * * `tar.gz` - TAR GZ
+ * * `tar.bz2` - TAR BZ2
+ */
+declare enum DocumentArchiveArchiveType {
+    ZIP = "zip",
+    TAR = "tar",
+    TAR_DOT_GZ = "tar.gz",
+    TAR_DOT_BZ2 = "tar.bz2"
+}
+/**
+ * * `pending` - Pending
+ * * `processing` - Processing
+ * * `completed` - Completed
+ * * `failed` - Failed
+ * * `cancelled` - Cancelled
+ */
+declare enum DocumentArchiveProcessingStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+/**
+ * Archive format
+ * * `zip` - ZIP
+ * * `tar` - TAR
+ * * `tar.gz` - TAR GZ
+ * * `tar.bz2` - TAR BZ2
+ */
+declare enum DocumentArchiveDetailArchiveType {
+    ZIP = "zip",
+    TAR = "tar",
+    TAR_DOT_GZ = "tar.gz",
+    TAR_DOT_BZ2 = "tar.bz2"
+}
+/**
+ * * `pending` - Pending
+ * * `processing` - Processing
+ * * `completed` - Completed
+ * * `failed` - Failed
+ * * `cancelled` - Cancelled
+ */
+declare enum DocumentArchiveDetailProcessingStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+/**
+ * Archive format
+ * * `zip` - ZIP
+ * * `tar` - TAR
+ * * `tar.gz` - TAR GZ
+ * * `tar.bz2` - TAR BZ2
+ */
+declare enum DocumentArchiveListArchiveType {
+    ZIP = "zip",
+    TAR = "tar",
+    TAR_DOT_GZ = "tar.gz",
+    TAR_DOT_BZ2 = "tar.bz2"
+}
+/**
+ * * `pending` - Pending
+ * * `processing` - Processing
+ * * `completed` - Completed
+ * * `failed` - Failed
+ * * `cancelled` - Cancelled
+ */
+declare enum DocumentArchiveListProcessingStatus {
+    PENDING = "pending",
+    PROCESSING = "processing",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled"
+}
+/**
+ * Type of content in chunk
+ * * `text` - Text
+ * * `code` - Code
+ * * `heading` - Heading
+ * * `metadata` - Metadata
+ * * `table` - Table
+ * * `list` - List
+ */
+declare enum PatchedArchiveItemChunkRequestChunkType {
+    TEXT = "text",
+    CODE = "code",
+    HEADING = "heading",
+    METADATA = "metadata",
+    TABLE = "table",
+    LIST = "list"
+}
+
+type GeneratedEnums_ArchiveItemChunkChunkType = ArchiveItemChunkChunkType;
+declare const GeneratedEnums_ArchiveItemChunkChunkType: typeof ArchiveItemChunkChunkType;
+type GeneratedEnums_ArchiveItemChunkDetailChunkType = ArchiveItemChunkDetailChunkType;
+declare const GeneratedEnums_ArchiveItemChunkDetailChunkType: typeof ArchiveItemChunkDetailChunkType;
+type GeneratedEnums_ArchiveItemChunkRequestChunkType = ArchiveItemChunkRequestChunkType;
+declare const GeneratedEnums_ArchiveItemChunkRequestChunkType: typeof ArchiveItemChunkRequestChunkType;
+type GeneratedEnums_ArchiveItemContentType = ArchiveItemContentType;
+declare const GeneratedEnums_ArchiveItemContentType: typeof ArchiveItemContentType;
+type GeneratedEnums_ArchiveItemDetailContentType = ArchiveItemDetailContentType;
+declare const GeneratedEnums_ArchiveItemDetailContentType: typeof ArchiveItemDetailContentType;
+type GeneratedEnums_ArchiveSearchRequestRequestChunkTypesItems = ArchiveSearchRequestRequestChunkTypesItems;
+declare const GeneratedEnums_ArchiveSearchRequestRequestChunkTypesItems: typeof ArchiveSearchRequestRequestChunkTypesItems;
+type GeneratedEnums_ArchiveSearchRequestRequestContentTypesItems = ArchiveSearchRequestRequestContentTypesItems;
+declare const GeneratedEnums_ArchiveSearchRequestRequestContentTypesItems: typeof ArchiveSearchRequestRequestContentTypesItems;
+type GeneratedEnums_ChatMessageRole = ChatMessageRole;
+declare const GeneratedEnums_ChatMessageRole: typeof ChatMessageRole;
+type GeneratedEnums_DocumentArchiveArchiveType = DocumentArchiveArchiveType;
+declare const GeneratedEnums_DocumentArchiveArchiveType: typeof DocumentArchiveArchiveType;
+type GeneratedEnums_DocumentArchiveDetailArchiveType = DocumentArchiveDetailArchiveType;
+declare const GeneratedEnums_DocumentArchiveDetailArchiveType: typeof DocumentArchiveDetailArchiveType;
+type GeneratedEnums_DocumentArchiveDetailProcessingStatus = DocumentArchiveDetailProcessingStatus;
+declare const GeneratedEnums_DocumentArchiveDetailProcessingStatus: typeof DocumentArchiveDetailProcessingStatus;
+type GeneratedEnums_DocumentArchiveListArchiveType = DocumentArchiveListArchiveType;
+declare const GeneratedEnums_DocumentArchiveListArchiveType: typeof DocumentArchiveListArchiveType;
+type GeneratedEnums_DocumentArchiveListProcessingStatus = DocumentArchiveListProcessingStatus;
+declare const GeneratedEnums_DocumentArchiveListProcessingStatus: typeof DocumentArchiveListProcessingStatus;
+type GeneratedEnums_DocumentArchiveProcessingStatus = DocumentArchiveProcessingStatus;
+declare const GeneratedEnums_DocumentArchiveProcessingStatus: typeof DocumentArchiveProcessingStatus;
+type GeneratedEnums_PatchedArchiveItemChunkRequestChunkType = PatchedArchiveItemChunkRequestChunkType;
+declare const GeneratedEnums_PatchedArchiveItemChunkRequestChunkType: typeof PatchedArchiveItemChunkRequestChunkType;
+declare namespace GeneratedEnums {
+  export { GeneratedEnums_ArchiveItemChunkChunkType as ArchiveItemChunkChunkType, GeneratedEnums_ArchiveItemChunkDetailChunkType as ArchiveItemChunkDetailChunkType, GeneratedEnums_ArchiveItemChunkRequestChunkType as ArchiveItemChunkRequestChunkType, GeneratedEnums_ArchiveItemContentType as ArchiveItemContentType, GeneratedEnums_ArchiveItemDetailContentType as ArchiveItemDetailContentType, GeneratedEnums_ArchiveSearchRequestRequestChunkTypesItems as ArchiveSearchRequestRequestChunkTypesItems, GeneratedEnums_ArchiveSearchRequestRequestContentTypesItems as ArchiveSearchRequestRequestContentTypesItems, GeneratedEnums_ChatMessageRole as ChatMessageRole, GeneratedEnums_DocumentArchiveArchiveType as DocumentArchiveArchiveType, GeneratedEnums_DocumentArchiveDetailArchiveType as DocumentArchiveDetailArchiveType, GeneratedEnums_DocumentArchiveDetailProcessingStatus as DocumentArchiveDetailProcessingStatus, GeneratedEnums_DocumentArchiveListArchiveType as DocumentArchiveListArchiveType, GeneratedEnums_DocumentArchiveListProcessingStatus as DocumentArchiveListProcessingStatus, GeneratedEnums_DocumentArchiveProcessingStatus as DocumentArchiveProcessingStatus, GeneratedEnums_PatchedArchiveItemChunkRequestChunkType as PatchedArchiveItemChunkRequestChunkType };
+}
+
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedChatResponseList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<ChatResponse$1>;
+}
+/**
+ * Chat response serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ChatResponseRequest$1 {
+    message_id: string;
+    content: string;
+    tokens_used: number;
+    cost_usd: number;
+    processing_time_ms: number;
+    model_used: string;
+    sources?: Array<ChatSourceRequest$1> | null;
+}
+/**
+ * Chat response serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ChatResponse$1 {
+    message_id: string;
+    content: string;
+    tokens_used: number;
+    cost_usd: number;
+    processing_time_ms: number;
+    model_used: string;
+    sources?: Array<ChatSource$2> | null;
+}
+/**
+ * Chat response serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedChatResponseRequest$1 {
+    message_id?: string;
+    content?: string;
+    tokens_used?: number;
+    cost_usd?: number;
+    processing_time_ms?: number;
+    model_used?: string;
+    sources?: Array<ChatSourceRequest$1> | null;
+}
+/**
+ * Chat history response serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ChatHistory$1 {
+    session_id: string;
+    messages: Array<ChatMessage$2>;
+    total_messages: number;
+}
+/**
+ * Chat query request serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ChatQueryRequest$1 {
+    /** Chat session ID (creates new if not provided) */
+    session_id?: string | null;
+    /** User query */
+    query: string;
+    /** Maximum response tokens */
+    max_tokens?: number;
+    /** Include source documents in response */
+    include_sources?: boolean;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedDocumentList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<Document$1>;
+}
+/**
+ * Document creation request serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface DocumentCreateRequest$1 {
+    /** Document title */
+    title: string;
+    /** Document content */
+    content: string;
+    /** MIME type */
+    file_type?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Document response serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface Document$1 {
+    id: string;
+    /** Document title */
+    title: string;
+    /** MIME type of original file */
+    file_type?: string;
+    /** Original file size in bytes */
+    file_size?: number;
+    processing_status: string;
+    chunks_count: number;
+    total_tokens: number;
+    total_cost_usd: number;
+    created_at: string;
+    updated_at: string;
+    processing_started_at: string;
+    processing_completed_at: string;
+    processing_error: string;
+    /** Additional document metadata */
+    metadata?: Record<string, any> | null;
+}
+/**
+ * Document response serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface DocumentRequest$1 {
+    /** Document title */
+    title: string;
+    /** MIME type of original file */
+    file_type?: string;
+    /** Original file size in bytes */
+    file_size?: number;
+    /** Additional document metadata */
+    metadata?: Record<string, any> | null;
+}
+/**
+ * Document response serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedDocumentRequest$1 {
+    /** Document title */
+    title?: string;
+    /** MIME type of original file */
+    file_type?: string;
+    /** Original file size in bytes */
+    file_size?: number;
+    /** Additional document metadata */
+    metadata?: Record<string, any> | null;
+}
+/**
+ * Document processing status serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface DocumentProcessingStatus$1 {
+    id: string;
+    status: string;
+    progress: Record<string, any>;
+    error?: string | null;
+    processing_time_seconds?: number | null;
+}
+/**
+ * Document processing statistics serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface DocumentStats$1 {
+    total_documents: number;
+    completed_documents: number;
+    processing_success_rate: number;
+    total_chunks: number;
+    total_tokens: number;
+    total_cost_usd: number;
+    avg_processing_time_seconds: number;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedChatSessionList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<ChatSession$1>;
+}
+/**
+ * Chat session creation request serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ChatSessionCreateRequest$1 {
+    /** Session title */
+    title?: string;
+    /** LLM model to use */
+    model_name?: string;
+    /** Response creativity */
+    temperature?: number;
+    /** Maximum context chunks */
+    max_context_chunks?: number;
+}
+/**
+ * Chat session response serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ChatSession$1 {
+    id: string;
+    /** Session title (auto-generated if empty) */
+    title?: string;
+    /** Whether session accepts new messages */
+    is_active?: boolean;
+    messages_count?: number;
+    total_tokens_used?: number;
+    total_cost_usd: number;
+    /** LLM model used for this session */
+    model_name?: string;
+    /** Temperature setting for LLM */
+    temperature?: number;
+    /** Maximum chunks to include in context */
+    max_context_chunks?: number;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Chat session response serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ChatSessionRequest$1 {
+    /** Session title (auto-generated if empty) */
+    title?: string;
+    /** Whether session accepts new messages */
+    is_active?: boolean;
+    messages_count?: number;
+    total_tokens_used?: number;
+    /** LLM model used for this session */
+    model_name?: string;
+    /** Temperature setting for LLM */
+    temperature?: number;
+    /** Maximum chunks to include in context */
+    max_context_chunks?: number;
+}
+/**
+ * Chat session response serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedChatSessionRequest$1 {
+    /** Session title (auto-generated if empty) */
+    title?: string;
+    /** Whether session accepts new messages */
+    is_active?: boolean;
+    messages_count?: number;
+    total_tokens_used?: number;
+    /** LLM model used for this session */
+    model_name?: string;
+    /** Temperature setting for LLM */
+    temperature?: number;
+    /** Maximum chunks to include in context */
+    max_context_chunks?: number;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedPublicCategoryList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<PublicCategory$1>;
+}
+/**
+ * Public category serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface PublicCategory$1 {
+    id: string;
+    /** Category name */
+    name: string;
+    /** Category description */
+    description?: string;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedPublicDocumentListList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<PublicDocumentList$1>;
+}
+/**
+ * Public document detail serializer - only essential data for clients.
+ *
+ * Response model (includes read-only fields).
+ */
+interface PublicDocument$1 {
+    id: string;
+    /** Document title */
+    title: string;
+    /** Full document content */
+    content: string;
+    category: PublicCategory$1;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedDocumentArchiveListList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<DocumentArchiveList$1>;
+}
+/**
+ * Archive processing result serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveProcessingResult$1 {
+    archive_id: string;
+    status: string;
+    processing_time_ms: number;
+    items_processed: number;
+    chunks_created: number;
+    vectorized_chunks: number;
+    total_cost_usd: number;
+    error_message: string;
+}
+/**
+ * Detailed archive serializer with items.
+ *
+ * Response model (includes read-only fields).
+ */
+interface DocumentArchiveDetail$1 {
+    id: string;
+    /** Archive title */
+    title: string;
+    /** Archive description */
+    description?: string;
+    categories: Array<DocumentCategory$1>;
+    /** Whether this archive is publicly accessible */
+    is_public?: boolean;
+    /** Uploaded archive file */
+    archive_file: string;
+    /** Original uploaded filename */
+    original_filename: string;
+    /** Archive size in bytes */
+    file_size: number;
+    /** Archive format
+  
+    * `zip` - ZIP
+    * `tar` - TAR
+    * `tar.gz` - TAR GZ
+    * `tar.bz2` - TAR BZ2 */
+    archive_type: DocumentArchiveDetailArchiveType;
+    /** * `pending` - Pending
+    * `processing` - Processing
+    * `completed` - Completed
+    * `failed` - Failed
+    * `cancelled` - Cancelled */
+    processing_status: DocumentArchiveDetailProcessingStatus;
+    /** When processing completed */
+    processed_at?: string | null;
+    /** Processing time in milliseconds */
+    processing_duration_ms: number;
+    /** Error message if processing failed */
+    processing_error: string;
+    /** Total items in archive */
+    total_items: number;
+    /** Successfully processed items */
+    processed_items: number;
+    /** Total chunks created */
+    total_chunks: number;
+    /** Chunks with embeddings */
+    vectorized_chunks: number;
+    /** Total tokens across all chunks */
+    total_tokens: number;
+    /** Total processing cost in USD */
+    total_cost_usd: number;
+    /** Calculate processing progress as percentage. */
+    processing_progress: number;
+    /** Calculate vectorization progress as percentage. */
+    vectorization_progress: number;
+    /** Check if archive processing is completed. */
+    is_processed: boolean;
+    created_at: string;
+    updated_at: string;
+    items: Array<ArchiveItem$1>;
+    /** Get hierarchical file tree. */
+    file_tree: Record<string, any>;
+    /** Additional archive metadata */
+    metadata?: Record<string, any> | null;
+}
+/**
+ * Document archive serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface DocumentArchiveRequest$1 {
+    /** Archive title */
+    title: string;
+    /** Archive description */
+    description?: string;
+    /** Whether this archive is publicly accessible */
+    is_public?: boolean;
+}
+/**
+ * Document archive serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface DocumentArchive$1 {
+    id: string;
+    /** Archive title */
+    title: string;
+    /** Archive description */
+    description?: string;
+    categories: Array<DocumentCategory$1>;
+    /** Whether this archive is publicly accessible */
+    is_public?: boolean;
+    /** Uploaded archive file */
+    archive_file: string;
+    /** Original uploaded filename */
+    original_filename: string;
+    /** Archive size in bytes */
+    file_size: number;
+    /** Archive format
+  
+    * `zip` - ZIP
+    * `tar` - TAR
+    * `tar.gz` - TAR GZ
+    * `tar.bz2` - TAR BZ2 */
+    archive_type: DocumentArchiveArchiveType;
+    /** * `pending` - Pending
+    * `processing` - Processing
+    * `completed` - Completed
+    * `failed` - Failed
+    * `cancelled` - Cancelled */
+    processing_status: DocumentArchiveProcessingStatus;
+    /** When processing completed */
+    processed_at?: string | null;
+    /** Processing time in milliseconds */
+    processing_duration_ms: number;
+    /** Error message if processing failed */
+    processing_error: string;
+    /** Total items in archive */
+    total_items: number;
+    /** Successfully processed items */
+    processed_items: number;
+    /** Total chunks created */
+    total_chunks: number;
+    /** Chunks with embeddings */
+    vectorized_chunks: number;
+    /** Total tokens across all chunks */
+    total_tokens: number;
+    /** Total processing cost in USD */
+    total_cost_usd: number;
+    /** Calculate processing progress as percentage. */
+    processing_progress: number;
+    /** Calculate vectorization progress as percentage. */
+    vectorization_progress: number;
+    /** Check if archive processing is completed. */
+    is_processed: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Document archive serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedDocumentArchiveRequest$1 {
+    /** Archive title */
+    title?: string;
+    /** Archive description */
+    description?: string;
+    /** Whether this archive is publicly accessible */
+    is_public?: boolean;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedArchiveItemList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<ArchiveItem$1>;
+}
+/**
+ * Archive search request serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ArchiveSearchRequestRequest$1 {
+    /** Search query */
+    query: string;
+    /** Filter by content types */
+    content_types?: Array<string>;
+    /** Filter by programming languages */
+    languages?: Array<string>;
+    /** Filter by chunk types */
+    chunk_types?: Array<string>;
+    /** Search within specific archives */
+    archive_ids?: Array<string>;
+    /** Maximum number of results */
+    limit?: number;
+    /** Minimum similarity threshold */
+    similarity_threshold?: number;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedArchiveSearchResultList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<ArchiveSearchResult$1>;
+}
+/**
+ * Chunk re-vectorization request serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ChunkRevectorizationRequestRequest$1 {
+    /** List of chunk IDs to re-vectorize */
+    chunk_ids: Array<string>;
+    /** Force re-vectorization even if already vectorized */
+    force?: boolean;
+}
+/**
+ * Vectorization result serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface VectorizationResult$1 {
+    vectorized_count: number;
+    failed_count: number;
+    total_tokens: number;
+    total_cost: number;
+    success_rate: number;
+    errors: Array<string>;
+}
+/**
+ * Archive statistics serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveStatistics$1 {
+    total_archives: number;
+    processed_archives: number;
+    failed_archives: number;
+    total_items: number;
+    total_chunks: number;
+    total_tokens: number;
+    total_cost: number;
+    avg_processing_time: number;
+    avg_items_per_archive: number;
+    avg_chunks_per_archive: number;
+}
+/**
+ * Vectorization statistics serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface VectorizationStatistics$1 {
+    total_chunks: number;
+    vectorized_chunks: number;
+    pending_chunks: number;
+    vectorization_rate: number;
+    total_tokens: number;
+    total_cost: number;
+    avg_tokens_per_chunk: number;
+    avg_cost_per_chunk: number;
+}
+/**
+ *
+ * Response model (includes read-only fields).
+ */
+interface PaginatedArchiveItemChunkList$1 {
+    /** Total number of items across all pages */
+    count: number;
+    /** Current page number (1-based) */
+    page: number;
+    /** Total number of pages */
+    pages: number;
+    /** Number of items per page */
+    page_size: number;
+    /** Whether there is a next page */
+    has_next: boolean;
+    /** Whether there is a previous page */
+    has_previous: boolean;
+    /** Next page number (null if no next page) */
+    next_page?: number | null;
+    /** Previous page number (null if no previous page) */
+    previous_page?: number | null;
+    /** Array of items for current page */
+    results: Array<ArchiveItemChunk$1>;
+}
+/**
+ * Archive item chunk serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ArchiveItemChunkRequest$1 {
+    /** Chunk text content */
+    content: string;
+    /** Sequential chunk number within item */
+    chunk_index: number;
+    /** Type of content in chunk
+  
+    * `text` - Text
+    * `code` - Code
+    * `heading` - Heading
+    * `metadata` - Metadata
+    * `table` - Table
+    * `list` - List */
+    chunk_type?: ArchiveItemChunkRequestChunkType;
+}
+/**
+ * Archive item chunk serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveItemChunk$1 {
+    id: string;
+    /** Chunk text content */
+    content: string;
+    /** Sequential chunk number within item */
+    chunk_index: number;
+    /** Type of content in chunk
+  
+    * `text` - Text
+    * `code` - Code
+    * `heading` - Heading
+    * `metadata` - Metadata
+    * `table` - Table
+    * `list` - List */
+    chunk_type?: ArchiveItemChunkChunkType;
+    /** Number of tokens in chunk */
+    token_count: number;
+    /** Number of characters in chunk */
+    character_count: number;
+    /** Model used for embedding generation */
+    embedding_model: string;
+    /** Cost in USD for embedding generation */
+    embedding_cost: number;
+    /** Get context summary for display. */
+    context_summary: Record<string, any>;
+    created_at: string;
+}
+/**
+ * Detailed chunk serializer with full context.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveItemChunkDetail$1 {
+    id: string;
+    /** Chunk text content */
+    content: string;
+    /** Sequential chunk number within item */
+    chunk_index: number;
+    /** Type of content in chunk
+  
+    * `text` - Text
+    * `code` - Code
+    * `heading` - Heading
+    * `metadata` - Metadata
+    * `table` - Table
+    * `list` - List */
+    chunk_type?: ArchiveItemChunkDetailChunkType;
+    /** Number of tokens in chunk */
+    token_count: number;
+    /** Number of characters in chunk */
+    character_count: number;
+    /** Model used for embedding generation */
+    embedding_model: string;
+    /** Cost in USD for embedding generation */
+    embedding_cost: number;
+    /** Get context summary for display. */
+    context_summary: Record<string, any>;
+    created_at: string;
+    context_metadata: Record<string, any>;
+}
+/**
+ * Archive item chunk serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedArchiveItemChunkRequest$1 {
+    /** Chunk text content */
+    content?: string;
+    /** Sequential chunk number within item */
+    chunk_index?: number;
+    /** Type of content in chunk
+  
+    * `text` - Text
+    * `code` - Code
+    * `heading` - Heading
+    * `metadata` - Metadata
+    * `table` - Table
+    * `list` - List */
+    chunk_type?: PatchedArchiveItemChunkRequestChunkType;
+}
+/**
+ * Archive item serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ArchiveItemRequest$1 {
+    /** Path within archive */
+    relative_path: string;
+    /** Item name */
+    item_name: string;
+    /** MIME type */
+    item_type: string;
+    /** Item size in bytes */
+    file_size?: number;
+}
+/**
+ * Archive item serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveItem$1 {
+    id: string;
+    /** Path within archive */
+    relative_path: string;
+    /** Item name */
+    item_name: string;
+    /** MIME type */
+    item_type: string;
+    /** Content classification
+  
+    * `document` - Document
+    * `code` - Code
+    * `image` - Image
+    * `data` - Data
+    * `archive` - Archive
+    * `unknown` - Unknown */
+    content_type: ArchiveItemContentType;
+    /** Item size in bytes */
+    file_size?: number;
+    /** Whether item can be processed for chunks */
+    is_processable: boolean;
+    /** Programming language or document language */
+    language: string;
+    /** Character encoding */
+    encoding: string;
+    /** Number of chunks created */
+    chunks_count: number;
+    /** Total tokens in all chunks */
+    total_tokens: number;
+    /** Processing cost for this item */
+    processing_cost: number;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Detailed archive item serializer with content.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveItemDetail$1 {
+    id: string;
+    /** Path within archive */
+    relative_path: string;
+    /** Item name */
+    item_name: string;
+    /** MIME type */
+    item_type: string;
+    /** Content classification
+  
+    * `document` - Document
+    * `code` - Code
+    * `image` - Image
+    * `data` - Data
+    * `archive` - Archive
+    * `unknown` - Unknown */
+    content_type: ArchiveItemDetailContentType;
+    /** Item size in bytes */
+    file_size?: number;
+    /** Whether item can be processed for chunks */
+    is_processable: boolean;
+    /** Programming language or document language */
+    language: string;
+    /** Character encoding */
+    encoding: string;
+    /** Number of chunks created */
+    chunks_count: number;
+    /** Total tokens in all chunks */
+    total_tokens: number;
+    /** Processing cost for this item */
+    processing_cost: number;
+    created_at: string;
+    updated_at: string;
+    raw_content: string;
+    metadata: Record<string, any>;
+}
+/**
+ * Archive item serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface PatchedArchiveItemRequest$1 {
+    /** Path within archive */
+    relative_path?: string;
+    /** Item name */
+    item_name?: string;
+    /** MIME type */
+    item_type?: string;
+    /** Item size in bytes */
+    file_size?: number;
+}
+/**
+ * Chat source document information serializer.
+ *
+ * Request model (no read-only fields).
+ */
+interface ChatSourceRequest$1 {
+    document_title: string;
+    chunk_content: string;
+    similarity: number;
+}
+/**
+ * Chat source document information serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ChatSource$2 {
+    document_title: string;
+    chunk_content: string;
+    similarity: number;
+}
+/**
+ * Chat message response serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ChatMessage$2 {
+    id: string;
+    /** Message sender role
+  
+    * `user` - User
+    * `assistant` - Assistant
+    * `system` - System */
+    role: ChatMessageRole;
+    /** Message content */
+    content: string;
+    /** Tokens used for this message */
+    tokens_used?: number;
+    cost_usd: number;
+    /** Processing time in milliseconds */
+    processing_time_ms?: number;
+    created_at: string;
+    /** IDs of chunks used for context */
+    context_chunks?: Record<string, any>;
+}
+/**
+ * Public document list serializer - minimal fields for listing.
+ *
+ * Response model (includes read-only fields).
+ */
+interface PublicDocumentList$1 {
+    id: string;
+    /** Document title */
+    title: string;
+    category: PublicCategory$1;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Simplified archive serializer for list views.
+ *
+ * Response model (includes read-only fields).
+ */
+interface DocumentArchiveList$1 {
+    id: string;
+    /** Archive title */
+    title: string;
+    /** Archive description */
+    description: string;
+    categories: Array<DocumentCategory$1>;
+    /** Whether this archive is publicly accessible */
+    is_public: boolean;
+    /** Original uploaded filename */
+    original_filename: string;
+    /** Archive size in bytes */
+    file_size: number;
+    /** Archive format
+  
+    * `zip` - ZIP
+    * `tar` - TAR
+    * `tar.gz` - TAR GZ
+    * `tar.bz2` - TAR BZ2 */
+    archive_type: DocumentArchiveListArchiveType;
+    /** * `pending` - Pending
+    * `processing` - Processing
+    * `completed` - Completed
+    * `failed` - Failed
+    * `cancelled` - Cancelled */
+    processing_status: DocumentArchiveListProcessingStatus;
+    /** When processing completed */
+    processed_at?: string | null;
+    /** Total items in archive */
+    total_items: number;
+    /** Total chunks created */
+    total_chunks: number;
+    /** Total processing cost in USD */
+    total_cost_usd: number;
+    /** Calculate processing progress as percentage. */
+    processing_progress: number;
+    created_at: string;
+}
+/**
+ * Document category serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface DocumentCategory$1 {
+    id: string;
+    /** Category name */
+    name: string;
+    /** Category description */
+    description?: string;
+    /** Whether documents in this category are publicly accessible */
+    is_public?: boolean;
+    created_at: string;
+}
+/**
+ * Archive search result serializer.
+ *
+ * Response model (includes read-only fields).
+ */
+interface ArchiveSearchResult$1 {
+    chunk: ArchiveItemChunk$1;
+    similarity_score: number;
+    context_summary: Record<string, any>;
+    archive_info: Record<string, any>;
+    item_info: Record<string, any>;
+}
+
+declare namespace models {
+  export type { ArchiveItem$1 as ArchiveItem, ArchiveItemChunk$1 as ArchiveItemChunk, ArchiveItemChunkDetail$1 as ArchiveItemChunkDetail, ArchiveItemChunkRequest$1 as ArchiveItemChunkRequest, ArchiveItemDetail$1 as ArchiveItemDetail, ArchiveItemRequest$1 as ArchiveItemRequest, ArchiveProcessingResult$1 as ArchiveProcessingResult, ArchiveSearchRequestRequest$1 as ArchiveSearchRequestRequest, ArchiveSearchResult$1 as ArchiveSearchResult, ArchiveStatistics$1 as ArchiveStatistics, ChatHistory$1 as ChatHistory, ChatMessage$2 as ChatMessage, ChatQueryRequest$1 as ChatQueryRequest, ChatResponse$1 as ChatResponse, ChatResponseRequest$1 as ChatResponseRequest, ChatSession$1 as ChatSession, ChatSessionCreateRequest$1 as ChatSessionCreateRequest, ChatSessionRequest$1 as ChatSessionRequest, ChatSource$2 as ChatSource, ChatSourceRequest$1 as ChatSourceRequest, ChunkRevectorizationRequestRequest$1 as ChunkRevectorizationRequestRequest, Document$1 as Document, DocumentArchive$1 as DocumentArchive, DocumentArchiveDetail$1 as DocumentArchiveDetail, DocumentArchiveList$1 as DocumentArchiveList, DocumentArchiveRequest$1 as DocumentArchiveRequest, DocumentCategory$1 as DocumentCategory, DocumentCreateRequest$1 as DocumentCreateRequest, DocumentProcessingStatus$1 as DocumentProcessingStatus, DocumentRequest$1 as DocumentRequest, DocumentStats$1 as DocumentStats, PaginatedArchiveItemChunkList$1 as PaginatedArchiveItemChunkList, PaginatedArchiveItemList$1 as PaginatedArchiveItemList, PaginatedArchiveSearchResultList$1 as PaginatedArchiveSearchResultList, PaginatedChatResponseList$1 as PaginatedChatResponseList, PaginatedChatSessionList$1 as PaginatedChatSessionList, PaginatedDocumentArchiveListList$1 as PaginatedDocumentArchiveListList, PaginatedDocumentList$1 as PaginatedDocumentList, PaginatedPublicCategoryList$1 as PaginatedPublicCategoryList, PaginatedPublicDocumentListList$1 as PaginatedPublicDocumentListList, PatchedArchiveItemChunkRequest$1 as PatchedArchiveItemChunkRequest, PatchedArchiveItemRequest$1 as PatchedArchiveItemRequest, PatchedChatResponseRequest$1 as PatchedChatResponseRequest, PatchedChatSessionRequest$1 as PatchedChatSessionRequest, PatchedDocumentArchiveRequest$1 as PatchedDocumentArchiveRequest, PatchedDocumentRequest$1 as PatchedDocumentRequest, PublicCategory$1 as PublicCategory, PublicDocument$1 as PublicDocument, PublicDocumentList$1 as PublicDocumentList, VectorizationResult$1 as VectorizationResult, VectorizationStatistics$1 as VectorizationStatistics };
+}
+
+/**
+ * API endpoints for Knowbase.
+ */
+declare class ExtKnowbaseKnowbase {
+    private client;
+    constructor(client: any);
+    adminChatList(page?: number, page_size?: number): Promise<PaginatedChatResponseList$1>;
+    adminChatList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedChatResponseList$1>;
+    /**
+     * Chat query endpoints.
+     */
+    adminChatCreate(data: ChatResponseRequest$1): Promise<ChatResponse$1>;
+    /**
+     * Chat query endpoints.
+     */
+    adminChatRetrieve(id: string): Promise<ChatResponse$1>;
+    /**
+     * Chat query endpoints.
+     */
+    adminChatUpdate(id: string, data: ChatResponseRequest$1): Promise<ChatResponse$1>;
+    /**
+     * Chat query endpoints.
+     */
+    adminChatPartialUpdate(id: string, data?: PatchedChatResponseRequest$1): Promise<ChatResponse$1>;
+    /**
+     * Chat query endpoints.
+     */
+    adminChatDestroy(id: string): Promise<void>;
+    /**
+     * Get chat history
+     *
+     * Get chat session history.
+     */
+    adminChatHistoryRetrieve(id: string): Promise<ChatHistory$1>;
+    /**
+     * Process chat query with RAG
+     *
+     * Process chat query with RAG context.
+     */
+    adminChatQueryCreate(data: ChatQueryRequest$1): Promise<ChatResponse$1>;
+    adminDocumentsList(page?: number, page_size?: number, status?: string): Promise<PaginatedDocumentList$1>;
+    adminDocumentsList(params?: {
+        page?: number;
+        page_size?: number;
+        status?: string;
+    }): Promise<PaginatedDocumentList$1>;
+    /**
+     * Upload new document
+     *
+     * Upload and process a new knowledge document
+     */
+    adminDocumentsCreate(data: DocumentCreateRequest$1): Promise<Document$1>;
+    /**
+     * Get document details
+     *
+     * Get document by ID.
+     */
+    adminDocumentsRetrieve(id: string): Promise<Document$1>;
+    /**
+     * Document management endpoints - Admin only.
+     */
+    adminDocumentsUpdate(id: string, data: DocumentRequest$1): Promise<Document$1>;
+    /**
+     * Document management endpoints - Admin only.
+     */
+    adminDocumentsPartialUpdate(id: string, data?: PatchedDocumentRequest$1): Promise<Document$1>;
+    /**
+     * Delete document
+     *
+     * Delete document and all associated chunks.
+     */
+    adminDocumentsDestroy(id: string): Promise<void>;
+    /**
+     * Reprocess document
+     *
+     * Trigger reprocessing of document chunks and embeddings
+     */
+    adminDocumentsReprocessCreate(id: string, data: DocumentRequest$1): Promise<Document$1>;
+    /**
+     * Get document processing status
+     *
+     * Get document processing status.
+     */
+    adminDocumentsStatusRetrieve(id: string): Promise<DocumentProcessingStatus$1>;
+    /**
+     * Get processing statistics
+     *
+     * Get user's document processing statistics.
+     */
+    adminDocumentsStatsRetrieve(): Promise<DocumentStats$1>;
+    adminSessionsList(page?: number, page_size?: number): Promise<PaginatedChatSessionList$1>;
+    adminSessionsList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedChatSessionList$1>;
+    /**
+     * Create new chat session
+     *
+     * Create new chat session.
+     */
+    adminSessionsCreate(data: ChatSessionCreateRequest$1): Promise<ChatSession$1>;
+    /**
+     * Chat session management endpoints.
+     */
+    adminSessionsRetrieve(id: string): Promise<ChatSession$1>;
+    /**
+     * Chat session management endpoints.
+     */
+    adminSessionsUpdate(id: string, data: ChatSessionRequest$1): Promise<ChatSession$1>;
+    /**
+     * Chat session management endpoints.
+     */
+    adminSessionsPartialUpdate(id: string, data?: PatchedChatSessionRequest$1): Promise<ChatSession$1>;
+    /**
+     * Chat session management endpoints.
+     */
+    adminSessionsDestroy(id: string): Promise<void>;
+    /**
+     * Activate chat session
+     *
+     * Activate chat session.
+     */
+    adminSessionsActivateCreate(id: string, data: ChatSessionRequest$1): Promise<ChatSession$1>;
+    /**
+     * Archive chat session
+     *
+     * Archive (deactivate) chat session.
+     */
+    adminSessionsArchiveCreate(id: string, data: ChatSessionRequest$1): Promise<ChatSession$1>;
+    categoriesList(page?: number, page_size?: number): Promise<PaginatedPublicCategoryList$1>;
+    categoriesList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedPublicCategoryList$1>;
+    /**
+     * Get public category details
+     *
+     * Get category details by ID (public access)
+     */
+    categoriesRetrieve(id: string): Promise<PublicCategory$1>;
+    documentsList(category?: string, page?: number, page_size?: number, search?: string): Promise<PaginatedPublicDocumentListList$1>;
+    documentsList(params?: {
+        category?: string;
+        page?: number;
+        page_size?: number;
+        search?: string;
+    }): Promise<PaginatedPublicDocumentListList$1>;
+    /**
+     * Get public document details
+     *
+     * Get document details by ID (public access)
+     */
+    documentsRetrieve(id: string): Promise<PublicDocument$1>;
+    systemArchivesList(page?: number, page_size?: number): Promise<PaginatedDocumentArchiveListList$1>;
+    systemArchivesList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedDocumentArchiveListList$1>;
+    /**
+     * Upload and process archive
+     *
+     * Upload archive file and process it synchronously
+     */
+    systemArchivesCreate(data: FormData): Promise<ArchiveProcessingResult$1>;
+    /**
+     * Document archive management endpoints - Admin only.
+     */
+    systemArchivesRetrieve(id: string): Promise<DocumentArchiveDetail$1>;
+    /**
+     * Document archive management endpoints - Admin only.
+     */
+    systemArchivesUpdate(id: string, data: DocumentArchiveRequest$1): Promise<DocumentArchive$1>;
+    /**
+     * Document archive management endpoints - Admin only.
+     */
+    systemArchivesPartialUpdate(id: string, data?: PatchedDocumentArchiveRequest$1): Promise<DocumentArchive$1>;
+    /**
+     * Document archive management endpoints - Admin only.
+     */
+    systemArchivesDestroy(id: string): Promise<void>;
+    /**
+     * Get archive file tree
+     *
+     * Get hierarchical file tree structure
+     */
+    systemArchivesFileTreeRetrieve(id: string): Promise<any>;
+    systemArchivesItemsList(id: string, page?: number, page_size?: number): Promise<PaginatedArchiveItemList$1>;
+    systemArchivesItemsList(id: string, params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedArchiveItemList$1>;
+    systemArchivesSearchCreate(id: string, data: ArchiveSearchRequestRequest$1, page?: number, page_size?: number): Promise<PaginatedArchiveSearchResultList$1>;
+    systemArchivesSearchCreate(id: string, data: ArchiveSearchRequestRequest$1, params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedArchiveSearchResultList$1>;
+    /**
+     * Re-vectorize chunks
+     *
+     * Re-vectorize specific chunks
+     */
+    systemArchivesRevectorizeCreate(data: ChunkRevectorizationRequestRequest$1): Promise<VectorizationResult$1>;
+    /**
+     * Get archive statistics
+     *
+     * Get processing and vectorization statistics
+     */
+    systemArchivesStatisticsRetrieve(): Promise<ArchiveStatistics$1>;
+    /**
+     * Get vectorization statistics
+     *
+     * Get vectorization statistics for archives
+     */
+    systemArchivesVectorizationStatsRetrieve(): Promise<VectorizationStatistics$1>;
+    systemChunksList(page?: number, page_size?: number): Promise<PaginatedArchiveItemChunkList$1>;
+    systemChunksList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedArchiveItemChunkList$1>;
+    /**
+     * Archive item chunk management endpoints - Admin only.
+     */
+    systemChunksCreate(data: ArchiveItemChunkRequest$1): Promise<ArchiveItemChunk$1>;
+    /**
+     * Archive item chunk management endpoints - Admin only.
+     */
+    systemChunksRetrieve(id: string): Promise<ArchiveItemChunkDetail$1>;
+    /**
+     * Archive item chunk management endpoints - Admin only.
+     */
+    systemChunksUpdate(id: string, data: ArchiveItemChunkRequest$1): Promise<ArchiveItemChunk$1>;
+    /**
+     * Archive item chunk management endpoints - Admin only.
+     */
+    systemChunksPartialUpdate(id: string, data?: PatchedArchiveItemChunkRequest$1): Promise<ArchiveItemChunk$1>;
+    /**
+     * Archive item chunk management endpoints - Admin only.
+     */
+    systemChunksDestroy(id: string): Promise<void>;
+    /**
+     * Get chunk context
+     *
+     * Get full context metadata for chunk
+     */
+    systemChunksContextRetrieve(id: string): Promise<ArchiveItemChunkDetail$1>;
+    /**
+     * Vectorize chunk
+     *
+     * Generate embedding for specific chunk
+     */
+    systemChunksVectorizeCreate(id: string, data: ArchiveItemChunkRequest$1): Promise<any>;
+    systemItemsList(page?: number, page_size?: number): Promise<PaginatedArchiveItemList$1>;
+    systemItemsList(params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedArchiveItemList$1>;
+    /**
+     * Archive item management endpoints - Admin only.
+     */
+    systemItemsCreate(data: ArchiveItemRequest$1): Promise<ArchiveItem$1>;
+    /**
+     * Archive item management endpoints - Admin only.
+     */
+    systemItemsRetrieve(id: string): Promise<ArchiveItemDetail$1>;
+    /**
+     * Archive item management endpoints - Admin only.
+     */
+    systemItemsUpdate(id: string, data: ArchiveItemRequest$1): Promise<ArchiveItem$1>;
+    /**
+     * Archive item management endpoints - Admin only.
+     */
+    systemItemsPartialUpdate(id: string, data?: PatchedArchiveItemRequest$1): Promise<ArchiveItem$1>;
+    /**
+     * Archive item management endpoints - Admin only.
+     */
+    systemItemsDestroy(id: string): Promise<void>;
+    systemItemsChunksList(id: string, page?: number, page_size?: number): Promise<PaginatedArchiveItemChunkList$1>;
+    systemItemsChunksList(id: string, params?: {
+        page?: number;
+        page_size?: number;
+    }): Promise<PaginatedArchiveItemChunkList$1>;
+    /**
+     * Get item content
+     *
+     * Get full content of archive item
+     */
+    systemItemsContentRetrieve(id: string): Promise<ArchiveItemDetail$1>;
+}
+
+/**
+ * HTTP Client Adapter Pattern
+ *
+ * Allows switching between fetch/axios/httpx without changing generated code.
+ * Provides unified interface for making HTTP requests.
+ */
+interface HttpRequest {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: any;
+    params?: Record<string, any>;
+    /** FormData for file uploads (multipart/form-data) */
+    formData?: FormData;
+}
+interface HttpResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+/**
+ * HTTP Client Adapter Interface.
+ * Implement this to use custom HTTP clients (axios, httpx, etc.)
+ */
+interface HttpClientAdapter {
+    request<T = any>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+/**
+ * Default Fetch API adapter.
+ * Uses native browser fetch() with proper error handling.
+ */
+declare class FetchAdapter implements HttpClientAdapter {
+    request<T = any>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+/**
+ * API Logger with Consola
+ * Beautiful console logging for API requests and responses
+ *
+ * Installation:
+ *   npm install consola
+ */
+
+/**
+ * Request log data
+ */
+interface RequestLog {
+    method: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: any;
+    timestamp: number;
+}
+/**
+ * Response log data
+ */
+interface ResponseLog {
+    status: number;
+    statusText: string;
+    data?: any;
+    duration: number;
+    timestamp: number;
+}
+/**
+ * Error log data
+ */
+interface ErrorLog {
+    message: string;
+    statusCode?: number;
+    fieldErrors?: Record<string, string[]>;
+    duration: number;
+    timestamp: number;
+}
+/**
+ * Logger configuration
+ */
+interface LoggerConfig {
+    /** Enable logging */
+    enabled: boolean;
+    /** Log requests */
+    logRequests: boolean;
+    /** Log responses */
+    logResponses: boolean;
+    /** Log errors */
+    logErrors: boolean;
+    /** Log request/response bodies */
+    logBodies: boolean;
+    /** Log headers (excluding sensitive ones) */
+    logHeaders: boolean;
+    /** Custom consola instance */
+    consola?: ConsolaInstance;
+}
+/**
+ * API Logger class
+ */
+declare class APILogger {
+    private config;
+    private consola;
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Enable logging
+     */
+    enable(): void;
+    /**
+     * Disable logging
+     */
+    disable(): void;
+    /**
+     * Update configuration
+     */
+    setConfig(config: Partial<LoggerConfig>): void;
+    /**
+     * Filter sensitive headers
+     */
+    private filterHeaders;
+    /**
+     * Log request
+     */
+    logRequest(request: RequestLog): void;
+    /**
+     * Log response
+     */
+    logResponse(request: RequestLog, response: ResponseLog): void;
+    /**
+     * Log error
+     */
+    logError(request: RequestLog, error: ErrorLog): void;
+    /**
+     * Log general info
+     */
+    info(message: string, ...args: any[]): void;
+    /**
+     * Log warning
+     */
+    warn(message: string, ...args: any[]): void;
+    /**
+     * Log error
+     */
+    error(message: string, ...args: any[]): void;
+    /**
+     * Log debug
+     */
+    debug(message: string, ...args: any[]): void;
+    /**
+     * Log success
+     */
+    success(message: string, ...args: any[]): void;
+    /**
+     * Create a sub-logger with prefix
+     */
+    withTag(tag: string): ConsolaInstance;
+}
+
+/**
+ * Retry Configuration and Utilities
+ *
+ * Provides automatic retry logic for failed HTTP requests using p-retry.
+ * Retries only on network errors and server errors (5xx), not client errors (4xx).
+ */
+/**
+ * Information about a failed retry attempt.
+ */
+interface FailedAttemptInfo {
+    /** The error that caused the failure */
+    error: Error;
+    /** The attempt number (1-indexed) */
+    attemptNumber: number;
+    /** Number of retries left */
+    retriesLeft: number;
+}
+/**
+ * Retry configuration options.
+ *
+ * Uses exponential backoff with jitter by default to avoid thundering herd.
+ */
+interface RetryConfig {
+    /**
+     * Maximum number of retry attempts.
+     * @default 3
+     */
+    retries?: number;
+    /**
+     * Exponential backoff factor.
+     * @default 2
+     */
+    factor?: number;
+    /**
+     * Minimum wait time between retries (ms).
+     * @default 1000
+     */
+    minTimeout?: number;
+    /**
+     * Maximum wait time between retries (ms).
+     * @default 60000
+     */
+    maxTimeout?: number;
+    /**
+     * Add randomness to wait times (jitter).
+     * Helps avoid thundering herd problem.
+     * @default true
+     */
+    randomize?: boolean;
+    /**
+     * Callback called on each failed attempt.
+     */
+    onFailedAttempt?: (info: FailedAttemptInfo) => void;
+}
+/**
+ * Default retry configuration.
+ */
+declare const DEFAULT_RETRY_CONFIG: Required<RetryConfig>;
+/**
+ * Determine if an error should trigger a retry.
+ *
+ * Retries on:
+ * - Network errors (connection refused, timeout, etc.)
+ * - Server errors (5xx status codes)
+ * - Rate limiting (429 status code)
+ *
+ * Does NOT retry on:
+ * - Client errors (4xx except 429)
+ * - Authentication errors (401, 403)
+ * - Not found (404)
+ *
+ * @param error - The error to check
+ * @returns true if should retry, false otherwise
+ */
+declare function shouldRetry(error: any): boolean;
+/**
+ * Wrap a function with retry logic.
+ *
+ * @param fn - Async function to retry
+ * @param config - Retry configuration
+ * @returns Result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   async () => fetch('https://api.example.com/users'),
+ *   { retries: 5, minTimeout: 2000 }
+ * );
+ * ```
+ */
+declare function withRetry<T>(fn: () => Promise<T>, config?: RetryConfig): Promise<T>;
+
+/**
+ * Async API client for Django CFG API.
+ *
+ * Usage:
+ * ```typescript
+ * const client = new APIClient('https://api.example.com');
+ * const users = await client.users.list();
+ * const post = await client.posts.create(newPost);
+ *
+ * // Custom HTTP adapter (e.g., Axios)
+ * const client = new APIClient('https://api.example.com', {
+ *   httpClient: new AxiosAdapter()
+ * });
+ * ```
+ */
+declare class APIClient {
+    private baseUrl;
+    private httpClient;
+    private logger;
+    private retryConfig;
+    ext_knowbase_knowbase: ExtKnowbaseKnowbase;
+    constructor(baseUrl: string, options?: {
+        httpClient?: HttpClientAdapter;
+        loggerConfig?: Partial<LoggerConfig>;
+        retryConfig?: RetryConfig;
+    });
+    /**
+     * Get CSRF token from cookies (for SessionAuthentication).
+     *
+     * Returns null if cookie doesn't exist (JWT-only auth).
+     */
+    getCsrfToken(): string | null;
+    /**
+     * Make HTTP request with Django CSRF and session handling.
+     * Automatically retries on network errors and 5xx server errors.
+     */
+    request<T>(method: string, path: string, options?: {
+        params?: Record<string, any>;
+        body?: any;
+        formData?: FormData;
+        headers?: Record<string, string>;
+    }): Promise<T>;
+    /**
+     * Internal request method (without retry wrapper).
+     * Used by request() method with optional retry logic.
+     */
+    private _makeRequest;
+}
+
+/**
+ * Storage adapters for cross-platform token storage.
+ *
+ * Supports:
+ * - LocalStorage (browser)
+ * - Cookies (SSR/browser)
+ * - Memory (Node.js/Electron/testing)
+ */
+
+/**
+ * Storage adapter interface for cross-platform token storage.
+ */
+interface StorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * LocalStorage adapter with safe try-catch for browser environments.
+ * Works in modern browsers with localStorage support.
+ *
+ * Note: This adapter uses window.localStorage and should only be used in browser/client environments.
+ * For server-side usage, use MemoryStorageAdapter or CookieStorageAdapter instead.
+ */
+declare class LocalStorageAdapter implements StorageAdapter {
+    private logger?;
+    constructor(logger?: APILogger);
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * Cookie-based storage adapter for SSR and browser environments.
+ * Useful for Next.js, Nuxt.js, and other SSR frameworks.
+ */
+declare class CookieStorageAdapter implements StorageAdapter {
+    private logger?;
+    constructor(logger?: APILogger);
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+/**
+ * In-memory storage adapter for Node.js, Electron, and testing environments.
+ * Data is stored in RAM and cleared when process exits.
+ */
+declare class MemoryStorageAdapter implements StorageAdapter {
+    private storage;
+    private logger?;
+    constructor(logger?: APILogger);
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+
+/**
+ * Zod schema for ArchiveItem
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive item serializer.
+ *  */
+
+/**
+ * Archive item serializer.
+ */
+declare const ArchiveItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    relative_path: z.ZodString;
+    item_name: z.ZodString;
+    item_type: z.ZodString;
+    content_type: z.ZodEnum<typeof ArchiveItemContentType>;
+    file_size: z.ZodOptional<z.ZodInt>;
+    is_processable: z.ZodBoolean;
+    language: z.ZodString;
+    encoding: z.ZodString;
+    chunks_count: z.ZodInt;
+    total_tokens: z.ZodInt;
+    processing_cost: z.ZodNumber;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveItem = z.infer<typeof ArchiveItemSchema>;
+
+/**
+ * Zod schema for ArchiveItemChunk
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive item chunk serializer.
+ *  */
+
+/**
+ * Archive item chunk serializer.
+ */
+declare const ArchiveItemChunkSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    chunk_index: z.ZodInt;
+    chunk_type: z.ZodOptional<z.ZodEnum<typeof ArchiveItemChunkChunkType>>;
+    token_count: z.ZodInt;
+    character_count: z.ZodInt;
+    embedding_model: z.ZodString;
+    embedding_cost: z.ZodNumber;
+    context_summary: z.ZodObject<{}, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveItemChunk = z.infer<typeof ArchiveItemChunkSchema>;
+
+/**
+ * Zod schema for ArchiveItemChunkDetail
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Detailed chunk serializer with full context.
+ *  */
+
+/**
+ * Detailed chunk serializer with full context.
+ */
+declare const ArchiveItemChunkDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    chunk_index: z.ZodInt;
+    chunk_type: z.ZodOptional<z.ZodEnum<typeof ArchiveItemChunkDetailChunkType>>;
+    token_count: z.ZodInt;
+    character_count: z.ZodInt;
+    embedding_model: z.ZodString;
+    embedding_cost: z.ZodNumber;
+    context_summary: z.ZodObject<{}, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+    context_metadata: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveItemChunkDetail = z.infer<typeof ArchiveItemChunkDetailSchema>;
+
+/**
+ * Zod schema for ArchiveItemChunkRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive item chunk serializer.
+ *  */
+
+/**
+ * Archive item chunk serializer.
+ */
+declare const ArchiveItemChunkRequestSchema: z.ZodObject<{
+    content: z.ZodString;
+    chunk_index: z.ZodInt;
+    chunk_type: z.ZodOptional<z.ZodEnum<typeof ArchiveItemChunkRequestChunkType>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveItemChunkRequest = z.infer<typeof ArchiveItemChunkRequestSchema>;
+
+/**
+ * Zod schema for ArchiveItemDetail
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Detailed archive item serializer with content.
+ *  */
+
+/**
+ * Detailed archive item serializer with content.
+ */
+declare const ArchiveItemDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    relative_path: z.ZodString;
+    item_name: z.ZodString;
+    item_type: z.ZodString;
+    content_type: z.ZodEnum<typeof ArchiveItemDetailContentType>;
+    file_size: z.ZodOptional<z.ZodInt>;
+    is_processable: z.ZodBoolean;
+    language: z.ZodString;
+    encoding: z.ZodString;
+    chunks_count: z.ZodInt;
+    total_tokens: z.ZodInt;
+    processing_cost: z.ZodNumber;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    raw_content: z.ZodString;
+    metadata: z.ZodRecord<z.ZodString, z.ZodAny>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveItemDetail = z.infer<typeof ArchiveItemDetailSchema>;
+
+/**
+ * Zod schema for ArchiveItemRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive item serializer.
+ *  */
+
+/**
+ * Archive item serializer.
+ */
+declare const ArchiveItemRequestSchema: z.ZodObject<{
+    relative_path: z.ZodString;
+    item_name: z.ZodString;
+    item_type: z.ZodString;
+    file_size: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveItemRequest = z.infer<typeof ArchiveItemRequestSchema>;
+
+/**
+ * Zod schema for ArchiveProcessingResult
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive processing result serializer.
+ *  */
+
+/**
+ * Archive processing result serializer.
+ */
+declare const ArchiveProcessingResultSchema: z.ZodObject<{
+    archive_id: z.ZodString;
+    status: z.ZodString;
+    processing_time_ms: z.ZodInt;
+    items_processed: z.ZodInt;
+    chunks_created: z.ZodInt;
+    vectorized_chunks: z.ZodInt;
+    total_cost_usd: z.ZodNumber;
+    error_message: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveProcessingResult = z.infer<typeof ArchiveProcessingResultSchema>;
+
+/**
+ * Zod schema for ArchiveSearchRequestRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive search request serializer.
+ *  */
+
+/**
+ * Archive search request serializer.
+ */
+declare const ArchiveSearchRequestRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    content_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    chunk_types: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    archive_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodInt>;
+    similarity_threshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveSearchRequestRequest = z.infer<typeof ArchiveSearchRequestRequestSchema>;
+
+/**
+ * Archive search result serializer.
+ */
+declare const ArchiveSearchResultSchema: z.ZodObject<{
+    chunk: z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        chunk_index: z.ZodInt;
+        chunk_type: z.ZodOptional<z.ZodEnum<typeof ArchiveItemChunkChunkType>>;
+        token_count: z.ZodInt;
+        character_count: z.ZodInt;
+        embedding_model: z.ZodString;
+        embedding_cost: z.ZodNumber;
+        context_summary: z.ZodObject<{}, z.core.$strip>;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>;
+    similarity_score: z.ZodNumber;
+    context_summary: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+    archive_info: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+    item_info: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveSearchResult = z.infer<typeof ArchiveSearchResultSchema>;
+
+/**
+ * Zod schema for ArchiveStatistics
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive statistics serializer.
+ *  */
+
+/**
+ * Archive statistics serializer.
+ */
+declare const ArchiveStatisticsSchema: z.ZodObject<{
+    total_archives: z.ZodInt;
+    processed_archives: z.ZodInt;
+    failed_archives: z.ZodInt;
+    total_items: z.ZodInt;
+    total_chunks: z.ZodInt;
+    total_tokens: z.ZodInt;
+    total_cost: z.ZodNumber;
+    avg_processing_time: z.ZodNumber;
+    avg_items_per_archive: z.ZodNumber;
+    avg_chunks_per_archive: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ArchiveStatistics = z.infer<typeof ArchiveStatisticsSchema>;
+
+/**
+ * Chat history response serializer.
+ */
+declare const ChatHistorySchema: z.ZodObject<{
+    session_id: z.ZodString;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodEnum<typeof ChatMessageRole>;
+        content: z.ZodString;
+        tokens_used: z.ZodOptional<z.ZodInt>;
+        cost_usd: z.ZodNumber;
+        processing_time_ms: z.ZodOptional<z.ZodInt>;
+        created_at: z.ZodISODateTime;
+        context_chunks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>;
+    total_messages: z.ZodInt;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatHistory = z.infer<typeof ChatHistorySchema>;
+
+/**
+ * Zod schema for ChatMessage
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat message response serializer.
+ *  */
+
+/**
+ * Chat message response serializer.
+ */
+declare const ChatMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodEnum<typeof ChatMessageRole>;
+    content: z.ZodString;
+    tokens_used: z.ZodOptional<z.ZodInt>;
+    cost_usd: z.ZodNumber;
+    processing_time_ms: z.ZodOptional<z.ZodInt>;
+    created_at: z.ZodISODateTime;
+    context_chunks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatMessage$1 = z.infer<typeof ChatMessageSchema>;
+
+/**
+ * Zod schema for ChatQueryRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat query request serializer.
+ *  */
+
+/**
+ * Chat query request serializer.
+ */
+declare const ChatQueryRequestSchema: z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    query: z.ZodString;
+    max_tokens: z.ZodOptional<z.ZodInt>;
+    include_sources: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatQueryRequest = z.infer<typeof ChatQueryRequestSchema>;
+
+/**
+ * Zod schema for ChatResponse
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat response serializer.
+ *  */
+
+/**
+ * Chat response serializer.
+ */
+declare const ChatResponseSchema: z.ZodObject<{
+    message_id: z.ZodString;
+    content: z.ZodString;
+    tokens_used: z.ZodInt;
+    cost_usd: z.ZodNumber;
+    processing_time_ms: z.ZodInt;
+    model_used: z.ZodString;
+    sources: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        document_title: z.ZodString;
+        chunk_content: z.ZodString;
+        similarity: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatResponse = z.infer<typeof ChatResponseSchema>;
+
+/**
+ * Zod schema for ChatResponseRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat response serializer.
+ *  */
+
+/**
+ * Chat response serializer.
+ */
+declare const ChatResponseRequestSchema: z.ZodObject<{
+    message_id: z.ZodString;
+    content: z.ZodString;
+    tokens_used: z.ZodInt;
+    cost_usd: z.ZodNumber;
+    processing_time_ms: z.ZodInt;
+    model_used: z.ZodString;
+    sources: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        document_title: z.ZodString;
+        chunk_content: z.ZodString;
+        similarity: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatResponseRequest = z.infer<typeof ChatResponseRequestSchema>;
+
+/**
+ * Zod schema for ChatSession
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat session response serializer.
+ *  */
+
+/**
+ * Chat session response serializer.
+ */
+declare const ChatSessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    is_active: z.ZodOptional<z.ZodBoolean>;
+    messages_count: z.ZodOptional<z.ZodInt>;
+    total_tokens_used: z.ZodOptional<z.ZodInt>;
+    total_cost_usd: z.ZodNumber;
+    model_name: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_context_chunks: z.ZodOptional<z.ZodInt>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatSession = z.infer<typeof ChatSessionSchema>;
+
+/**
+ * Zod schema for ChatSessionCreateRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat session creation request serializer.
+ *  */
+
+/**
+ * Chat session creation request serializer.
+ */
+declare const ChatSessionCreateRequestSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    model_name: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_context_chunks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatSessionCreateRequest = z.infer<typeof ChatSessionCreateRequestSchema>;
+
+/**
+ * Zod schema for ChatSessionRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat session response serializer.
+ *  */
+
+/**
+ * Chat session response serializer.
+ */
+declare const ChatSessionRequestSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    is_active: z.ZodOptional<z.ZodBoolean>;
+    messages_count: z.ZodOptional<z.ZodInt>;
+    total_tokens_used: z.ZodOptional<z.ZodInt>;
+    model_name: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_context_chunks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatSessionRequest = z.infer<typeof ChatSessionRequestSchema>;
+
+/**
+ * Zod schema for ChatSource
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat source document information serializer.
+ *  */
+
+/**
+ * Chat source document information serializer.
+ */
+declare const ChatSourceSchema: z.ZodObject<{
+    document_title: z.ZodString;
+    chunk_content: z.ZodString;
+    similarity: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatSource$1 = z.infer<typeof ChatSourceSchema>;
+
+/**
+ * Zod schema for ChatSourceRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat source document information serializer.
+ *  */
+
+/**
+ * Chat source document information serializer.
+ */
+declare const ChatSourceRequestSchema: z.ZodObject<{
+    document_title: z.ZodString;
+    chunk_content: z.ZodString;
+    similarity: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChatSourceRequest = z.infer<typeof ChatSourceRequestSchema>;
+
+/**
+ * Zod schema for ChunkRevectorizationRequestRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chunk re-vectorization request serializer.
+ *  */
+
+/**
+ * Chunk re-vectorization request serializer.
+ */
+declare const ChunkRevectorizationRequestRequestSchema: z.ZodObject<{
+    chunk_ids: z.ZodArray<z.ZodString>;
+    force: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type ChunkRevectorizationRequestRequest = z.infer<typeof ChunkRevectorizationRequestRequestSchema>;
+
+/**
+ * Zod schema for Document
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document response serializer.
+ *  */
+
+/**
+ * Document response serializer.
+ */
+declare const DocumentSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    file_type: z.ZodOptional<z.ZodString>;
+    file_size: z.ZodOptional<z.ZodInt>;
+    processing_status: z.ZodString;
+    chunks_count: z.ZodInt;
+    total_tokens: z.ZodInt;
+    total_cost_usd: z.ZodNumber;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    processing_started_at: z.ZodISODateTime;
+    processing_completed_at: z.ZodISODateTime;
+    processing_error: z.ZodString;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type Document = z.infer<typeof DocumentSchema>;
+
+/**
+ * Zod schema for DocumentArchive
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document archive serializer.
+ *  */
+
+/**
+ * Document archive serializer.
+ */
+declare const DocumentArchiveSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        is_public: z.ZodOptional<z.ZodBoolean>;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+    archive_file: z.ZodURL;
+    original_filename: z.ZodString;
+    file_size: z.ZodInt;
+    archive_type: z.ZodEnum<typeof DocumentArchiveArchiveType>;
+    processing_status: z.ZodEnum<typeof DocumentArchiveProcessingStatus>;
+    processed_at: z.ZodNullable<z.ZodISODateTime>;
+    processing_duration_ms: z.ZodInt;
+    processing_error: z.ZodString;
+    total_items: z.ZodInt;
+    processed_items: z.ZodInt;
+    total_chunks: z.ZodInt;
+    vectorized_chunks: z.ZodInt;
+    total_tokens: z.ZodInt;
+    total_cost_usd: z.ZodNumber;
+    processing_progress: z.ZodNumber;
+    vectorization_progress: z.ZodNumber;
+    is_processed: z.ZodBoolean;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentArchive = z.infer<typeof DocumentArchiveSchema>;
+
+/**
+ * Zod schema for DocumentArchiveDetail
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Detailed archive serializer with items.
+ *  */
+
+/**
+ * Detailed archive serializer with items.
+ */
+declare const DocumentArchiveDetailSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        is_public: z.ZodOptional<z.ZodBoolean>;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+    archive_file: z.ZodURL;
+    original_filename: z.ZodString;
+    file_size: z.ZodInt;
+    archive_type: z.ZodEnum<typeof DocumentArchiveDetailArchiveType>;
+    processing_status: z.ZodEnum<typeof DocumentArchiveDetailProcessingStatus>;
+    processed_at: z.ZodNullable<z.ZodISODateTime>;
+    processing_duration_ms: z.ZodInt;
+    processing_error: z.ZodString;
+    total_items: z.ZodInt;
+    processed_items: z.ZodInt;
+    total_chunks: z.ZodInt;
+    vectorized_chunks: z.ZodInt;
+    total_tokens: z.ZodInt;
+    total_cost_usd: z.ZodNumber;
+    processing_progress: z.ZodNumber;
+    vectorization_progress: z.ZodNumber;
+    is_processed: z.ZodBoolean;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        relative_path: z.ZodString;
+        item_name: z.ZodString;
+        item_type: z.ZodString;
+        content_type: z.ZodEnum<typeof ArchiveItemContentType>;
+        file_size: z.ZodOptional<z.ZodInt>;
+        is_processable: z.ZodBoolean;
+        language: z.ZodString;
+        encoding: z.ZodString;
+        chunks_count: z.ZodInt;
+        total_tokens: z.ZodInt;
+        processing_cost: z.ZodNumber;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    file_tree: z.ZodRecord<z.ZodString, z.ZodAny>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentArchiveDetail = z.infer<typeof DocumentArchiveDetailSchema>;
+
+/**
+ * Zod schema for DocumentArchiveList
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Simplified archive serializer for list views.
+ *  */
+
+/**
+ * Simplified archive serializer for list views.
+ */
+declare const DocumentArchiveListSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    categories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        is_public: z.ZodOptional<z.ZodBoolean>;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+    is_public: z.ZodBoolean;
+    original_filename: z.ZodString;
+    file_size: z.ZodInt;
+    archive_type: z.ZodEnum<typeof DocumentArchiveListArchiveType>;
+    processing_status: z.ZodEnum<typeof DocumentArchiveListProcessingStatus>;
+    processed_at: z.ZodNullable<z.ZodISODateTime>;
+    total_items: z.ZodInt;
+    total_chunks: z.ZodInt;
+    total_cost_usd: z.ZodNumber;
+    processing_progress: z.ZodNumber;
+    created_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentArchiveList = z.infer<typeof DocumentArchiveListSchema>;
+
+/**
+ * Zod schema for DocumentArchiveRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document archive serializer.
+ *  */
+
+/**
+ * Document archive serializer.
+ */
+declare const DocumentArchiveRequestSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentArchiveRequest = z.infer<typeof DocumentArchiveRequestSchema>;
+
+/**
+ * Zod schema for DocumentCategory
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document category serializer.
+ *  */
+
+/**
+ * Document category serializer.
+ */
+declare const DocumentCategorySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+    created_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentCategory = z.infer<typeof DocumentCategorySchema>;
+
+/**
+ * Zod schema for DocumentCategoryRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document category serializer.
+ *  */
+
+/**
+ * Document category serializer.
+ */
+declare const DocumentCategoryRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentCategoryRequest = z.infer<typeof DocumentCategoryRequestSchema>;
+
+/**
+ * Zod schema for DocumentCreateRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document creation request serializer.
+ *  */
+
+/**
+ * Document creation request serializer.
+ */
+declare const DocumentCreateRequestSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    file_type: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentCreateRequest = z.infer<typeof DocumentCreateRequestSchema>;
+
+/**
+ * Zod schema for DocumentProcessingStatus
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document processing status serializer.
+ *  */
+
+/**
+ * Document processing status serializer.
+ */
+declare const DocumentProcessingStatusSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodString;
+    progress: z.ZodRecord<z.ZodString, z.ZodAny>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    processing_time_seconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentProcessingStatus = z.infer<typeof DocumentProcessingStatusSchema>;
+
+/**
+ * Zod schema for DocumentRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document response serializer.
+ *  */
+
+/**
+ * Document response serializer.
+ */
+declare const DocumentRequestSchema: z.ZodObject<{
+    title: z.ZodString;
+    file_type: z.ZodOptional<z.ZodString>;
+    file_size: z.ZodOptional<z.ZodInt>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentRequest = z.infer<typeof DocumentRequestSchema>;
+
+/**
+ * Zod schema for DocumentStats
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document processing statistics serializer.
+ *  */
+
+/**
+ * Document processing statistics serializer.
+ */
+declare const DocumentStatsSchema: z.ZodObject<{
+    total_documents: z.ZodInt;
+    completed_documents: z.ZodInt;
+    processing_success_rate: z.ZodNumber;
+    total_chunks: z.ZodInt;
+    total_tokens: z.ZodInt;
+    total_cost_usd: z.ZodNumber;
+    avg_processing_time_seconds: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type DocumentStats = z.infer<typeof DocumentStatsSchema>;
+
+declare const PaginatedArchiveItemChunkListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        content: z.ZodString;
+        chunk_index: z.ZodInt;
+        chunk_type: z.ZodOptional<z.ZodEnum<typeof ArchiveItemChunkChunkType>>;
+        token_count: z.ZodInt;
+        character_count: z.ZodInt;
+        embedding_model: z.ZodString;
+        embedding_cost: z.ZodNumber;
+        context_summary: z.ZodObject<{}, z.core.$strip>;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedArchiveItemChunkList = z.infer<typeof PaginatedArchiveItemChunkListSchema>;
+
+declare const PaginatedArchiveItemListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        relative_path: z.ZodString;
+        item_name: z.ZodString;
+        item_type: z.ZodString;
+        content_type: z.ZodEnum<typeof ArchiveItemContentType>;
+        file_size: z.ZodOptional<z.ZodInt>;
+        is_processable: z.ZodBoolean;
+        language: z.ZodString;
+        encoding: z.ZodString;
+        chunks_count: z.ZodInt;
+        total_tokens: z.ZodInt;
+        processing_cost: z.ZodNumber;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedArchiveItemList = z.infer<typeof PaginatedArchiveItemListSchema>;
+
+declare const PaginatedArchiveSearchResultListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        chunk: z.ZodObject<{
+            id: z.ZodString;
+            content: z.ZodString;
+            chunk_index: z.ZodInt;
+            chunk_type: z.ZodOptional<z.ZodEnum<typeof ArchiveItemChunkChunkType>>;
+            token_count: z.ZodInt;
+            character_count: z.ZodInt;
+            embedding_model: z.ZodString;
+            embedding_cost: z.ZodNumber;
+            context_summary: z.ZodObject<{}, z.core.$strip>;
+            created_at: z.ZodISODateTime;
+        }, z.core.$strip>;
+        similarity_score: z.ZodNumber;
+        context_summary: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+        archive_info: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+        item_info: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedArchiveSearchResultList = z.infer<typeof PaginatedArchiveSearchResultListSchema>;
+
+/**
+ * Zod schema for PaginatedChatResponseList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PaginatedChatResponseListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        message_id: z.ZodString;
+        content: z.ZodString;
+        tokens_used: z.ZodInt;
+        cost_usd: z.ZodNumber;
+        processing_time_ms: z.ZodInt;
+        model_used: z.ZodString;
+        sources: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            document_title: z.ZodString;
+            chunk_content: z.ZodString;
+            similarity: z.ZodNumber;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedChatResponseList = z.infer<typeof PaginatedChatResponseListSchema>;
+
+/**
+ * Zod schema for PaginatedChatSessionList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PaginatedChatSessionListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodOptional<z.ZodString>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+        messages_count: z.ZodOptional<z.ZodInt>;
+        total_tokens_used: z.ZodOptional<z.ZodInt>;
+        total_cost_usd: z.ZodNumber;
+        model_name: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        max_context_chunks: z.ZodOptional<z.ZodInt>;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedChatSessionList = z.infer<typeof PaginatedChatSessionListSchema>;
+
+declare const PaginatedDocumentArchiveListListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        categories: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            is_public: z.ZodOptional<z.ZodBoolean>;
+            created_at: z.ZodISODateTime;
+        }, z.core.$strip>>;
+        is_public: z.ZodBoolean;
+        original_filename: z.ZodString;
+        file_size: z.ZodInt;
+        archive_type: z.ZodEnum<typeof DocumentArchiveListArchiveType>;
+        processing_status: z.ZodEnum<typeof DocumentArchiveListProcessingStatus>;
+        processed_at: z.ZodNullable<z.ZodISODateTime>;
+        total_items: z.ZodInt;
+        total_chunks: z.ZodInt;
+        total_cost_usd: z.ZodNumber;
+        processing_progress: z.ZodNumber;
+        created_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedDocumentArchiveListList = z.infer<typeof PaginatedDocumentArchiveListListSchema>;
+
+/**
+ * Zod schema for PaginatedDocumentList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PaginatedDocumentListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        file_type: z.ZodOptional<z.ZodString>;
+        file_size: z.ZodOptional<z.ZodInt>;
+        processing_status: z.ZodString;
+        chunks_count: z.ZodInt;
+        total_tokens: z.ZodInt;
+        total_cost_usd: z.ZodNumber;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+        processing_started_at: z.ZodISODateTime;
+        processing_completed_at: z.ZodISODateTime;
+        processing_error: z.ZodString;
+        metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedDocumentList = z.infer<typeof PaginatedDocumentListSchema>;
+
+/**
+ * Zod schema for PaginatedPublicCategoryList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PaginatedPublicCategoryListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedPublicCategoryList = z.infer<typeof PaginatedPublicCategoryListSchema>;
+
+/**
+ * Zod schema for PaginatedPublicDocumentListList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+
+declare const PaginatedPublicDocumentListListSchema: z.ZodObject<{
+    count: z.ZodInt;
+    page: z.ZodInt;
+    pages: z.ZodInt;
+    page_size: z.ZodInt;
+    has_next: z.ZodBoolean;
+    has_previous: z.ZodBoolean;
+    next_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    previous_page: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        category: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        created_at: z.ZodISODateTime;
+        updated_at: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PaginatedPublicDocumentListList = z.infer<typeof PaginatedPublicDocumentListListSchema>;
+
+/**
+ * Zod schema for PatchedArchiveItemChunkRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive item chunk serializer.
+ *  */
+
+/**
+ * Archive item chunk serializer.
+ */
+declare const PatchedArchiveItemChunkRequestSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+    chunk_index: z.ZodOptional<z.ZodInt>;
+    chunk_type: z.ZodOptional<z.ZodEnum<typeof PatchedArchiveItemChunkRequestChunkType>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedArchiveItemChunkRequest = z.infer<typeof PatchedArchiveItemChunkRequestSchema>;
+
+/**
+ * Zod schema for PatchedArchiveItemRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Archive item serializer.
+ *  */
+
+/**
+ * Archive item serializer.
+ */
+declare const PatchedArchiveItemRequestSchema: z.ZodObject<{
+    relative_path: z.ZodOptional<z.ZodString>;
+    item_name: z.ZodOptional<z.ZodString>;
+    item_type: z.ZodOptional<z.ZodString>;
+    file_size: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedArchiveItemRequest = z.infer<typeof PatchedArchiveItemRequestSchema>;
+
+/**
+ * Zod schema for PatchedChatResponseRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat response serializer.
+ *  */
+
+/**
+ * Chat response serializer.
+ */
+declare const PatchedChatResponseRequestSchema: z.ZodObject<{
+    message_id: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    tokens_used: z.ZodOptional<z.ZodInt>;
+    cost_usd: z.ZodOptional<z.ZodNumber>;
+    processing_time_ms: z.ZodOptional<z.ZodInt>;
+    model_used: z.ZodOptional<z.ZodString>;
+    sources: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        document_title: z.ZodString;
+        chunk_content: z.ZodString;
+        similarity: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedChatResponseRequest = z.infer<typeof PatchedChatResponseRequestSchema>;
+
+/**
+ * Zod schema for PatchedChatSessionRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Chat session response serializer.
+ *  */
+
+/**
+ * Chat session response serializer.
+ */
+declare const PatchedChatSessionRequestSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    is_active: z.ZodOptional<z.ZodBoolean>;
+    messages_count: z.ZodOptional<z.ZodInt>;
+    total_tokens_used: z.ZodOptional<z.ZodInt>;
+    model_name: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_context_chunks: z.ZodOptional<z.ZodInt>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedChatSessionRequest = z.infer<typeof PatchedChatSessionRequestSchema>;
+
+/**
+ * Zod schema for PatchedDocumentArchiveRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document archive serializer.
+ *  */
+
+/**
+ * Document archive serializer.
+ */
+declare const PatchedDocumentArchiveRequestSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    is_public: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedDocumentArchiveRequest = z.infer<typeof PatchedDocumentArchiveRequestSchema>;
+
+/**
+ * Zod schema for PatchedDocumentRequest
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Document response serializer.
+ *  */
+
+/**
+ * Document response serializer.
+ */
+declare const PatchedDocumentRequestSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    file_type: z.ZodOptional<z.ZodString>;
+    file_size: z.ZodOptional<z.ZodInt>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PatchedDocumentRequest = z.infer<typeof PatchedDocumentRequestSchema>;
+
+/**
+ * Zod schema for PublicCategory
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Public category serializer.
+ *  */
+
+/**
+ * Public category serializer.
+ */
+declare const PublicCategorySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PublicCategory = z.infer<typeof PublicCategorySchema>;
+
+/**
+ * Zod schema for PublicDocument
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Public document detail serializer - only essential data for clients.
+ *  */
+
+/**
+ * Public document detail serializer - only essential data for clients.
+ */
+declare const PublicDocumentSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    category: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PublicDocument = z.infer<typeof PublicDocumentSchema>;
+
+/**
+ * Zod schema for PublicDocumentList
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Public document list serializer - minimal fields for listing.
+ *  */
+
+/**
+ * Public document list serializer - minimal fields for listing.
+ */
+declare const PublicDocumentListSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    category: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    created_at: z.ZodISODateTime;
+    updated_at: z.ZodISODateTime;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type PublicDocumentList = z.infer<typeof PublicDocumentListSchema>;
+
+/**
+ * Zod schema for VectorizationResult
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Vectorization result serializer.
+ *  */
+
+/**
+ * Vectorization result serializer.
+ */
+declare const VectorizationResultSchema: z.ZodObject<{
+    vectorized_count: z.ZodInt;
+    failed_count: z.ZodInt;
+    total_tokens: z.ZodInt;
+    total_cost: z.ZodNumber;
+    success_rate: z.ZodNumber;
+    errors: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type VectorizationResult = z.infer<typeof VectorizationResultSchema>;
+
+/**
+ * Zod schema for VectorizationStatistics
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Vectorization statistics serializer.
+ *  */
+
+/**
+ * Vectorization statistics serializer.
+ */
+declare const VectorizationStatisticsSchema: z.ZodObject<{
+    total_chunks: z.ZodInt;
+    vectorized_chunks: z.ZodInt;
+    pending_chunks: z.ZodInt;
+    vectorization_rate: z.ZodNumber;
+    total_tokens: z.ZodInt;
+    total_cost: z.ZodNumber;
+    avg_tokens_per_chunk: z.ZodNumber;
+    avg_cost_per_chunk: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Infer TypeScript type from Zod schema
+ */
+type VectorizationStatistics = z.infer<typeof VectorizationStatisticsSchema>;
+
+/**
+ * Zod Schemas - Runtime validation and type inference
+ *
+ * Auto-generated from OpenAPI specification.
+ * Provides runtime validation for API requests and responses.
+ *
+ * Usage:
+ * ```typescript
+ * import { UserSchema } from './schemas'
+ *
+ * // Validate data
+ * const user = UserSchema.parse(data)
+ *
+ * // Type inference
+ * type User = z.infer<typeof UserSchema>
+ * ```
+ */
+
+type index$1_ArchiveItem = ArchiveItem;
+type index$1_ArchiveItemChunk = ArchiveItemChunk;
+type index$1_ArchiveItemChunkDetail = ArchiveItemChunkDetail;
+declare const index$1_ArchiveItemChunkDetailSchema: typeof ArchiveItemChunkDetailSchema;
+type index$1_ArchiveItemChunkRequest = ArchiveItemChunkRequest;
+declare const index$1_ArchiveItemChunkRequestSchema: typeof ArchiveItemChunkRequestSchema;
+declare const index$1_ArchiveItemChunkSchema: typeof ArchiveItemChunkSchema;
+type index$1_ArchiveItemDetail = ArchiveItemDetail;
+declare const index$1_ArchiveItemDetailSchema: typeof ArchiveItemDetailSchema;
+type index$1_ArchiveItemRequest = ArchiveItemRequest;
+declare const index$1_ArchiveItemRequestSchema: typeof ArchiveItemRequestSchema;
+declare const index$1_ArchiveItemSchema: typeof ArchiveItemSchema;
+type index$1_ArchiveProcessingResult = ArchiveProcessingResult;
+declare const index$1_ArchiveProcessingResultSchema: typeof ArchiveProcessingResultSchema;
+type index$1_ArchiveSearchRequestRequest = ArchiveSearchRequestRequest;
+declare const index$1_ArchiveSearchRequestRequestSchema: typeof ArchiveSearchRequestRequestSchema;
+type index$1_ArchiveSearchResult = ArchiveSearchResult;
+declare const index$1_ArchiveSearchResultSchema: typeof ArchiveSearchResultSchema;
+type index$1_ArchiveStatistics = ArchiveStatistics;
+declare const index$1_ArchiveStatisticsSchema: typeof ArchiveStatisticsSchema;
+type index$1_ChatHistory = ChatHistory;
+declare const index$1_ChatHistorySchema: typeof ChatHistorySchema;
+declare const index$1_ChatMessageSchema: typeof ChatMessageSchema;
+type index$1_ChatQueryRequest = ChatQueryRequest;
+declare const index$1_ChatQueryRequestSchema: typeof ChatQueryRequestSchema;
+type index$1_ChatResponse = ChatResponse;
+type index$1_ChatResponseRequest = ChatResponseRequest;
+declare const index$1_ChatResponseRequestSchema: typeof ChatResponseRequestSchema;
+declare const index$1_ChatResponseSchema: typeof ChatResponseSchema;
+type index$1_ChatSession = ChatSession;
+type index$1_ChatSessionCreateRequest = ChatSessionCreateRequest;
+declare const index$1_ChatSessionCreateRequestSchema: typeof ChatSessionCreateRequestSchema;
+type index$1_ChatSessionRequest = ChatSessionRequest;
+declare const index$1_ChatSessionRequestSchema: typeof ChatSessionRequestSchema;
+declare const index$1_ChatSessionSchema: typeof ChatSessionSchema;
+type index$1_ChatSourceRequest = ChatSourceRequest;
+declare const index$1_ChatSourceRequestSchema: typeof ChatSourceRequestSchema;
+declare const index$1_ChatSourceSchema: typeof ChatSourceSchema;
+type index$1_ChunkRevectorizationRequestRequest = ChunkRevectorizationRequestRequest;
+declare const index$1_ChunkRevectorizationRequestRequestSchema: typeof ChunkRevectorizationRequestRequestSchema;
+type index$1_Document = Document;
+type index$1_DocumentArchive = DocumentArchive;
+type index$1_DocumentArchiveDetail = DocumentArchiveDetail;
+declare const index$1_DocumentArchiveDetailSchema: typeof DocumentArchiveDetailSchema;
+type index$1_DocumentArchiveList = DocumentArchiveList;
+declare const index$1_DocumentArchiveListSchema: typeof DocumentArchiveListSchema;
+type index$1_DocumentArchiveRequest = DocumentArchiveRequest;
+declare const index$1_DocumentArchiveRequestSchema: typeof DocumentArchiveRequestSchema;
+declare const index$1_DocumentArchiveSchema: typeof DocumentArchiveSchema;
+type index$1_DocumentCategory = DocumentCategory;
+type index$1_DocumentCategoryRequest = DocumentCategoryRequest;
+declare const index$1_DocumentCategoryRequestSchema: typeof DocumentCategoryRequestSchema;
+declare const index$1_DocumentCategorySchema: typeof DocumentCategorySchema;
+type index$1_DocumentCreateRequest = DocumentCreateRequest;
+declare const index$1_DocumentCreateRequestSchema: typeof DocumentCreateRequestSchema;
+type index$1_DocumentProcessingStatus = DocumentProcessingStatus;
+declare const index$1_DocumentProcessingStatusSchema: typeof DocumentProcessingStatusSchema;
+type index$1_DocumentRequest = DocumentRequest;
+declare const index$1_DocumentRequestSchema: typeof DocumentRequestSchema;
+declare const index$1_DocumentSchema: typeof DocumentSchema;
+type index$1_DocumentStats = DocumentStats;
+declare const index$1_DocumentStatsSchema: typeof DocumentStatsSchema;
+type index$1_PaginatedArchiveItemChunkList = PaginatedArchiveItemChunkList;
+declare const index$1_PaginatedArchiveItemChunkListSchema: typeof PaginatedArchiveItemChunkListSchema;
+type index$1_PaginatedArchiveItemList = PaginatedArchiveItemList;
+declare const index$1_PaginatedArchiveItemListSchema: typeof PaginatedArchiveItemListSchema;
+type index$1_PaginatedArchiveSearchResultList = PaginatedArchiveSearchResultList;
+declare const index$1_PaginatedArchiveSearchResultListSchema: typeof PaginatedArchiveSearchResultListSchema;
+type index$1_PaginatedChatResponseList = PaginatedChatResponseList;
+declare const index$1_PaginatedChatResponseListSchema: typeof PaginatedChatResponseListSchema;
+type index$1_PaginatedChatSessionList = PaginatedChatSessionList;
+declare const index$1_PaginatedChatSessionListSchema: typeof PaginatedChatSessionListSchema;
+type index$1_PaginatedDocumentArchiveListList = PaginatedDocumentArchiveListList;
+declare const index$1_PaginatedDocumentArchiveListListSchema: typeof PaginatedDocumentArchiveListListSchema;
+type index$1_PaginatedDocumentList = PaginatedDocumentList;
+declare const index$1_PaginatedDocumentListSchema: typeof PaginatedDocumentListSchema;
+type index$1_PaginatedPublicCategoryList = PaginatedPublicCategoryList;
+declare const index$1_PaginatedPublicCategoryListSchema: typeof PaginatedPublicCategoryListSchema;
+type index$1_PaginatedPublicDocumentListList = PaginatedPublicDocumentListList;
+declare const index$1_PaginatedPublicDocumentListListSchema: typeof PaginatedPublicDocumentListListSchema;
+type index$1_PatchedArchiveItemChunkRequest = PatchedArchiveItemChunkRequest;
+declare const index$1_PatchedArchiveItemChunkRequestSchema: typeof PatchedArchiveItemChunkRequestSchema;
+type index$1_PatchedArchiveItemRequest = PatchedArchiveItemRequest;
+declare const index$1_PatchedArchiveItemRequestSchema: typeof PatchedArchiveItemRequestSchema;
+type index$1_PatchedChatResponseRequest = PatchedChatResponseRequest;
+declare const index$1_PatchedChatResponseRequestSchema: typeof PatchedChatResponseRequestSchema;
+type index$1_PatchedChatSessionRequest = PatchedChatSessionRequest;
+declare const index$1_PatchedChatSessionRequestSchema: typeof PatchedChatSessionRequestSchema;
+type index$1_PatchedDocumentArchiveRequest = PatchedDocumentArchiveRequest;
+declare const index$1_PatchedDocumentArchiveRequestSchema: typeof PatchedDocumentArchiveRequestSchema;
+type index$1_PatchedDocumentRequest = PatchedDocumentRequest;
+declare const index$1_PatchedDocumentRequestSchema: typeof PatchedDocumentRequestSchema;
+type index$1_PublicCategory = PublicCategory;
+declare const index$1_PublicCategorySchema: typeof PublicCategorySchema;
+type index$1_PublicDocument = PublicDocument;
+type index$1_PublicDocumentList = PublicDocumentList;
+declare const index$1_PublicDocumentListSchema: typeof PublicDocumentListSchema;
+declare const index$1_PublicDocumentSchema: typeof PublicDocumentSchema;
+type index$1_VectorizationResult = VectorizationResult;
+declare const index$1_VectorizationResultSchema: typeof VectorizationResultSchema;
+type index$1_VectorizationStatistics = VectorizationStatistics;
+declare const index$1_VectorizationStatisticsSchema: typeof VectorizationStatisticsSchema;
+declare namespace index$1 {
+  export { type index$1_ArchiveItem as ArchiveItem, type index$1_ArchiveItemChunk as ArchiveItemChunk, type index$1_ArchiveItemChunkDetail as ArchiveItemChunkDetail, index$1_ArchiveItemChunkDetailSchema as ArchiveItemChunkDetailSchema, type index$1_ArchiveItemChunkRequest as ArchiveItemChunkRequest, index$1_ArchiveItemChunkRequestSchema as ArchiveItemChunkRequestSchema, index$1_ArchiveItemChunkSchema as ArchiveItemChunkSchema, type index$1_ArchiveItemDetail as ArchiveItemDetail, index$1_ArchiveItemDetailSchema as ArchiveItemDetailSchema, type index$1_ArchiveItemRequest as ArchiveItemRequest, index$1_ArchiveItemRequestSchema as ArchiveItemRequestSchema, index$1_ArchiveItemSchema as ArchiveItemSchema, type index$1_ArchiveProcessingResult as ArchiveProcessingResult, index$1_ArchiveProcessingResultSchema as ArchiveProcessingResultSchema, type index$1_ArchiveSearchRequestRequest as ArchiveSearchRequestRequest, index$1_ArchiveSearchRequestRequestSchema as ArchiveSearchRequestRequestSchema, type index$1_ArchiveSearchResult as ArchiveSearchResult, index$1_ArchiveSearchResultSchema as ArchiveSearchResultSchema, type index$1_ArchiveStatistics as ArchiveStatistics, index$1_ArchiveStatisticsSchema as ArchiveStatisticsSchema, type index$1_ChatHistory as ChatHistory, index$1_ChatHistorySchema as ChatHistorySchema, type ChatMessage$1 as ChatMessage, index$1_ChatMessageSchema as ChatMessageSchema, type index$1_ChatQueryRequest as ChatQueryRequest, index$1_ChatQueryRequestSchema as ChatQueryRequestSchema, type index$1_ChatResponse as ChatResponse, type index$1_ChatResponseRequest as ChatResponseRequest, index$1_ChatResponseRequestSchema as ChatResponseRequestSchema, index$1_ChatResponseSchema as ChatResponseSchema, type index$1_ChatSession as ChatSession, type index$1_ChatSessionCreateRequest as ChatSessionCreateRequest, index$1_ChatSessionCreateRequestSchema as ChatSessionCreateRequestSchema, type index$1_ChatSessionRequest as ChatSessionRequest, index$1_ChatSessionRequestSchema as ChatSessionRequestSchema, index$1_ChatSessionSchema as ChatSessionSchema, type ChatSource$1 as ChatSource, type index$1_ChatSourceRequest as ChatSourceRequest, index$1_ChatSourceRequestSchema as ChatSourceRequestSchema, index$1_ChatSourceSchema as ChatSourceSchema, type index$1_ChunkRevectorizationRequestRequest as ChunkRevectorizationRequestRequest, index$1_ChunkRevectorizationRequestRequestSchema as ChunkRevectorizationRequestRequestSchema, type index$1_Document as Document, type index$1_DocumentArchive as DocumentArchive, type index$1_DocumentArchiveDetail as DocumentArchiveDetail, index$1_DocumentArchiveDetailSchema as DocumentArchiveDetailSchema, type index$1_DocumentArchiveList as DocumentArchiveList, index$1_DocumentArchiveListSchema as DocumentArchiveListSchema, type index$1_DocumentArchiveRequest as DocumentArchiveRequest, index$1_DocumentArchiveRequestSchema as DocumentArchiveRequestSchema, index$1_DocumentArchiveSchema as DocumentArchiveSchema, type index$1_DocumentCategory as DocumentCategory, type index$1_DocumentCategoryRequest as DocumentCategoryRequest, index$1_DocumentCategoryRequestSchema as DocumentCategoryRequestSchema, index$1_DocumentCategorySchema as DocumentCategorySchema, type index$1_DocumentCreateRequest as DocumentCreateRequest, index$1_DocumentCreateRequestSchema as DocumentCreateRequestSchema, type index$1_DocumentProcessingStatus as DocumentProcessingStatus, index$1_DocumentProcessingStatusSchema as DocumentProcessingStatusSchema, type index$1_DocumentRequest as DocumentRequest, index$1_DocumentRequestSchema as DocumentRequestSchema, index$1_DocumentSchema as DocumentSchema, type index$1_DocumentStats as DocumentStats, index$1_DocumentStatsSchema as DocumentStatsSchema, type index$1_PaginatedArchiveItemChunkList as PaginatedArchiveItemChunkList, index$1_PaginatedArchiveItemChunkListSchema as PaginatedArchiveItemChunkListSchema, type index$1_PaginatedArchiveItemList as PaginatedArchiveItemList, index$1_PaginatedArchiveItemListSchema as PaginatedArchiveItemListSchema, type index$1_PaginatedArchiveSearchResultList as PaginatedArchiveSearchResultList, index$1_PaginatedArchiveSearchResultListSchema as PaginatedArchiveSearchResultListSchema, type index$1_PaginatedChatResponseList as PaginatedChatResponseList, index$1_PaginatedChatResponseListSchema as PaginatedChatResponseListSchema, type index$1_PaginatedChatSessionList as PaginatedChatSessionList, index$1_PaginatedChatSessionListSchema as PaginatedChatSessionListSchema, type index$1_PaginatedDocumentArchiveListList as PaginatedDocumentArchiveListList, index$1_PaginatedDocumentArchiveListListSchema as PaginatedDocumentArchiveListListSchema, type index$1_PaginatedDocumentList as PaginatedDocumentList, index$1_PaginatedDocumentListSchema as PaginatedDocumentListSchema, type index$1_PaginatedPublicCategoryList as PaginatedPublicCategoryList, index$1_PaginatedPublicCategoryListSchema as PaginatedPublicCategoryListSchema, type index$1_PaginatedPublicDocumentListList as PaginatedPublicDocumentListList, index$1_PaginatedPublicDocumentListListSchema as PaginatedPublicDocumentListListSchema, type index$1_PatchedArchiveItemChunkRequest as PatchedArchiveItemChunkRequest, index$1_PatchedArchiveItemChunkRequestSchema as PatchedArchiveItemChunkRequestSchema, type index$1_PatchedArchiveItemRequest as PatchedArchiveItemRequest, index$1_PatchedArchiveItemRequestSchema as PatchedArchiveItemRequestSchema, type index$1_PatchedChatResponseRequest as PatchedChatResponseRequest, index$1_PatchedChatResponseRequestSchema as PatchedChatResponseRequestSchema, type index$1_PatchedChatSessionRequest as PatchedChatSessionRequest, index$1_PatchedChatSessionRequestSchema as PatchedChatSessionRequestSchema, type index$1_PatchedDocumentArchiveRequest as PatchedDocumentArchiveRequest, index$1_PatchedDocumentArchiveRequestSchema as PatchedDocumentArchiveRequestSchema, type index$1_PatchedDocumentRequest as PatchedDocumentRequest, index$1_PatchedDocumentRequestSchema as PatchedDocumentRequestSchema, type index$1_PublicCategory as PublicCategory, index$1_PublicCategorySchema as PublicCategorySchema, type index$1_PublicDocument as PublicDocument, type index$1_PublicDocumentList as PublicDocumentList, index$1_PublicDocumentListSchema as PublicDocumentListSchema, index$1_PublicDocumentSchema as PublicDocumentSchema, type index$1_VectorizationResult as VectorizationResult, index$1_VectorizationResultSchema as VectorizationResultSchema, type index$1_VectorizationStatistics as VectorizationStatistics, index$1_VectorizationStatisticsSchema as VectorizationStatisticsSchema };
+}
+
+/**
+ * Zod Validation Events - Browser CustomEvent integration
+ *
+ * Dispatches browser CustomEvents when Zod validation fails, allowing
+ * React/frontend apps to listen and handle validation errors globally.
+ *
+ * @example
+ * ```typescript
+ * // In your React app
+ * window.addEventListener('zod-validation-error', (event) => {
+ *   const { operation, path, method, error, response } = event.detail;
+ *   console.error(`Validation failed for ${method} ${path}`, error);
+ *   // Show toast notification, log to Sentry, etc.
+ * });
+ * ```
+ */
+
+/**
+ * Validation error event detail
+ */
+interface ValidationErrorDetail {
+    /** Operation/function name that failed validation */
+    operation: string;
+    /** API endpoint path */
+    path: string;
+    /** HTTP method */
+    method: string;
+    /** Zod validation error */
+    error: ZodError;
+    /** Raw response data that failed validation */
+    response: any;
+    /** Timestamp of the error */
+    timestamp: Date;
+}
+/**
+ * Custom event type for Zod validation errors
+ */
+type ValidationErrorEvent = CustomEvent<ValidationErrorDetail>;
+/**
+ * Dispatch a Zod validation error event.
+ *
+ * Only dispatches in browser environment (when window is defined).
+ * Safe to call in Node.js/SSR - will be a no-op.
+ *
+ * @param detail - Validation error details
+ */
+declare function dispatchValidationError(detail: ValidationErrorDetail): void;
+/**
+ * Add a global listener for Zod validation errors.
+ *
+ * @param callback - Function to call when validation error occurs
+ * @returns Cleanup function to remove the listener
+ *
+ * @example
+ * ```typescript
+ * const cleanup = onValidationError(({ operation, error }) => {
+ *   toast.error(`Validation failed in ${operation}`);
+ *   logToSentry(error);
+ * });
+ *
+ * // Later, remove listener
+ * cleanup();
+ * ```
+ */
+declare function onValidationError(callback: (detail: ValidationErrorDetail) => void): () => void;
+/**
+ * Format Zod error for logging/display.
+ *
+ * @param error - Zod validation error
+ * @returns Formatted error message
+ */
+declare function formatZodError(error: ZodError): string;
+
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/chat/
+ */
+declare function getKnowbaseAdminChatList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedChatResponseList>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/chat/
+ */
+declare function createKnowbaseAdminChatCreate(data: ChatResponseRequest, client?: any): Promise<ChatResponse>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/chat/{id}/
+ */
+declare function getKnowbaseAdminChatRetrieve(id: string, client?: any): Promise<ChatResponse>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/knowbase/admin/chat/{id}/
+ */
+declare function updateKnowbaseAdminChatUpdate(id: string, data: ChatResponseRequest, client?: any): Promise<ChatResponse>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/knowbase/admin/chat/{id}/
+ */
+declare function partialUpdateKnowbaseAdminChatPartialUpdate(id: string, data?: PatchedChatResponseRequest, client?: any): Promise<ChatResponse>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/knowbase/admin/chat/{id}/
+ */
+declare function deleteKnowbaseAdminChatDestroy(id: string, client?: any): Promise<void>;
+/**
+ * Get chat history
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/chat/{id}/history/
+ */
+declare function getKnowbaseAdminChatHistoryRetrieve(id: string, client?: any): Promise<ChatHistory>;
+/**
+ * Process chat query with RAG
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/chat/query/
+ */
+declare function createKnowbaseAdminChatQueryCreate(data: ChatQueryRequest, client?: any): Promise<ChatResponse>;
+/**
+ * List user documents
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/documents/
+ */
+declare function getKnowbaseAdminDocumentsList(params?: {
+    page?: number;
+    page_size?: number;
+    status?: string;
+}, client?: any): Promise<PaginatedDocumentList>;
+/**
+ * Upload new document
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/documents/
+ */
+declare function createKnowbaseAdminDocumentsCreate(data: DocumentCreateRequest, client?: any): Promise<Document>;
+/**
+ * Get document details
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/documents/{id}/
+ */
+declare function getKnowbaseAdminDocumentsRetrieve(id: string, client?: any): Promise<Document>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/knowbase/admin/documents/{id}/
+ */
+declare function updateKnowbaseAdminDocumentsUpdate(id: string, data: DocumentRequest, client?: any): Promise<Document>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/knowbase/admin/documents/{id}/
+ */
+declare function partialUpdateKnowbaseAdminDocumentsPartialUpdate(id: string, data?: PatchedDocumentRequest, client?: any): Promise<Document>;
+/**
+ * Delete document
+ *
+ * @method DELETE
+ * @path /cfg/knowbase/admin/documents/{id}/
+ */
+declare function deleteKnowbaseAdminDocumentsDestroy(id: string, client?: any): Promise<void>;
+/**
+ * Reprocess document
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/documents/{id}/reprocess/
+ */
+declare function createKnowbaseAdminDocumentsReprocessCreate(id: string, data: DocumentRequest, client?: any): Promise<Document>;
+/**
+ * Get document processing status
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/documents/{id}/status/
+ */
+declare function getKnowbaseAdminDocumentsStatusRetrieve(id: string, client?: any): Promise<DocumentProcessingStatus>;
+/**
+ * Get processing statistics
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/documents/stats/
+ */
+declare function getKnowbaseAdminDocumentsStatsRetrieve(client?: any): Promise<DocumentStats>;
+/**
+ * List user chat sessions
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/sessions/
+ */
+declare function getKnowbaseAdminSessionsList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedChatSessionList>;
+/**
+ * Create new chat session
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/sessions/
+ */
+declare function createKnowbaseAdminSessionsCreate(data: ChatSessionCreateRequest, client?: any): Promise<ChatSession>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/admin/sessions/{id}/
+ */
+declare function getKnowbaseAdminSessionsRetrieve(id: string, client?: any): Promise<ChatSession>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/knowbase/admin/sessions/{id}/
+ */
+declare function updateKnowbaseAdminSessionsUpdate(id: string, data: ChatSessionRequest, client?: any): Promise<ChatSession>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/knowbase/admin/sessions/{id}/
+ */
+declare function partialUpdateKnowbaseAdminSessionsPartialUpdate(id: string, data?: PatchedChatSessionRequest, client?: any): Promise<ChatSession>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/knowbase/admin/sessions/{id}/
+ */
+declare function deleteKnowbaseAdminSessionsDestroy(id: string, client?: any): Promise<void>;
+/**
+ * Activate chat session
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/sessions/{id}/activate/
+ */
+declare function createKnowbaseAdminSessionsActivateCreate(id: string, data: ChatSessionRequest, client?: any): Promise<ChatSession>;
+/**
+ * Archive chat session
+ *
+ * @method POST
+ * @path /cfg/knowbase/admin/sessions/{id}/archive/
+ */
+declare function createKnowbaseAdminSessionsArchiveCreate(id: string, data: ChatSessionRequest, client?: any): Promise<ChatSession>;
+/**
+ * List public categories
+ *
+ * @method GET
+ * @path /cfg/knowbase/categories/
+ */
+declare function getKnowbaseCategoriesList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedPublicCategoryList>;
+/**
+ * Get public category details
+ *
+ * @method GET
+ * @path /cfg/knowbase/categories/{id}/
+ */
+declare function getKnowbaseCategoriesRetrieve(id: string, client?: any): Promise<PublicCategory>;
+/**
+ * List public documents
+ *
+ * @method GET
+ * @path /cfg/knowbase/documents/
+ */
+declare function getKnowbaseDocumentsList(params?: {
+    category?: string;
+    page?: number;
+    page_size?: number;
+    search?: string;
+}, client?: any): Promise<PaginatedPublicDocumentListList>;
+/**
+ * Get public document details
+ *
+ * @method GET
+ * @path /cfg/knowbase/documents/{id}/
+ */
+declare function getKnowbaseDocumentsRetrieve(id: string, client?: any): Promise<PublicDocument>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/archives/
+ */
+declare function getKnowbaseSystemArchivesList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedDocumentArchiveListList>;
+/**
+ * Upload and process archive
+ *
+ * @method POST
+ * @path /cfg/knowbase/system/archives/
+ */
+declare function createKnowbaseSystemArchivesCreate(data: any, client?: any): Promise<ArchiveProcessingResult>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/archives/{id}/
+ */
+declare function getKnowbaseSystemArchivesRetrieve(id: string, client?: any): Promise<DocumentArchiveDetail>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/knowbase/system/archives/{id}/
+ */
+declare function updateKnowbaseSystemArchivesUpdate(id: string, data: DocumentArchiveRequest, client?: any): Promise<DocumentArchive>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/knowbase/system/archives/{id}/
+ */
+declare function partialUpdateKnowbaseSystemArchivesPartialUpdate(id: string, data?: PatchedDocumentArchiveRequest, client?: any): Promise<DocumentArchive>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/knowbase/system/archives/{id}/
+ */
+declare function deleteKnowbaseSystemArchivesDestroy(id: string, client?: any): Promise<void>;
+/**
+ * Get archive file tree
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/archives/{id}/file_tree/
+ */
+declare function getKnowbaseSystemArchivesFileTreeRetrieve(id: string, client?: any): Promise<any>;
+/**
+ * Get archive items
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/archives/{id}/items/
+ */
+declare function getKnowbaseSystemArchivesItemsList(id: string, params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedArchiveItemList>;
+/**
+ * Search archive chunks
+ *
+ * @method POST
+ * @path /cfg/knowbase/system/archives/{id}/search/
+ */
+declare function createKnowbaseSystemArchivesSearchCreate(id: string, data: ArchiveSearchRequestRequest, params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedArchiveSearchResultList>;
+/**
+ * Re-vectorize chunks
+ *
+ * @method POST
+ * @path /cfg/knowbase/system/archives/revectorize/
+ */
+declare function createKnowbaseSystemArchivesRevectorizeCreate(data: ChunkRevectorizationRequestRequest, client?: any): Promise<VectorizationResult>;
+/**
+ * Get archive statistics
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/archives/statistics/
+ */
+declare function getKnowbaseSystemArchivesStatisticsRetrieve(client?: any): Promise<ArchiveStatistics>;
+/**
+ * Get vectorization statistics
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/archives/vectorization_stats/
+ */
+declare function getKnowbaseSystemArchivesVectorizationStatsRetrieve(client?: any): Promise<VectorizationStatistics>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/chunks/
+ */
+declare function getKnowbaseSystemChunksList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedArchiveItemChunkList>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/knowbase/system/chunks/
+ */
+declare function createKnowbaseSystemChunksCreate(data: ArchiveItemChunkRequest, client?: any): Promise<ArchiveItemChunk>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/chunks/{id}/
+ */
+declare function getKnowbaseSystemChunksRetrieve(id: string, client?: any): Promise<ArchiveItemChunkDetail>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/knowbase/system/chunks/{id}/
+ */
+declare function updateKnowbaseSystemChunksUpdate(id: string, data: ArchiveItemChunkRequest, client?: any): Promise<ArchiveItemChunk>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/knowbase/system/chunks/{id}/
+ */
+declare function partialUpdateKnowbaseSystemChunksPartialUpdate(id: string, data?: PatchedArchiveItemChunkRequest, client?: any): Promise<ArchiveItemChunk>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/knowbase/system/chunks/{id}/
+ */
+declare function deleteKnowbaseSystemChunksDestroy(id: string, client?: any): Promise<void>;
+/**
+ * Get chunk context
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/chunks/{id}/context/
+ */
+declare function getKnowbaseSystemChunksContextRetrieve(id: string, client?: any): Promise<ArchiveItemChunkDetail>;
+/**
+ * Vectorize chunk
+ *
+ * @method POST
+ * @path /cfg/knowbase/system/chunks/{id}/vectorize/
+ */
+declare function createKnowbaseSystemChunksVectorizeCreate(id: string, data: ArchiveItemChunkRequest, client?: any): Promise<any>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/items/
+ */
+declare function getKnowbaseSystemItemsList(params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedArchiveItemList>;
+/**
+ * API operation
+ *
+ * @method POST
+ * @path /cfg/knowbase/system/items/
+ */
+declare function createKnowbaseSystemItemsCreate(data: ArchiveItemRequest, client?: any): Promise<ArchiveItem>;
+/**
+ * API operation
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/items/{id}/
+ */
+declare function getKnowbaseSystemItemsRetrieve(id: string, client?: any): Promise<ArchiveItemDetail>;
+/**
+ * API operation
+ *
+ * @method PUT
+ * @path /cfg/knowbase/system/items/{id}/
+ */
+declare function updateKnowbaseSystemItemsUpdate(id: string, data: ArchiveItemRequest, client?: any): Promise<ArchiveItem>;
+/**
+ * API operation
+ *
+ * @method PATCH
+ * @path /cfg/knowbase/system/items/{id}/
+ */
+declare function partialUpdateKnowbaseSystemItemsPartialUpdate(id: string, data?: PatchedArchiveItemRequest, client?: any): Promise<ArchiveItem>;
+/**
+ * API operation
+ *
+ * @method DELETE
+ * @path /cfg/knowbase/system/items/{id}/
+ */
+declare function deleteKnowbaseSystemItemsDestroy(id: string, client?: any): Promise<void>;
+/**
+ * Get item chunks
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/items/{id}/chunks/
+ */
+declare function getKnowbaseSystemItemsChunksList(id: string, params?: {
+    page?: number;
+    page_size?: number;
+}, client?: any): Promise<PaginatedArchiveItemChunkList>;
+/**
+ * Get item content
+ *
+ * @method GET
+ * @path /cfg/knowbase/system/items/{id}/content/
+ */
+declare function getKnowbaseSystemItemsContentRetrieve(id: string, client?: any): Promise<ArchiveItemDetail>;
+
+/**
+ * Typed Fetchers - Universal API functions
+ *
+ * Auto-generated from OpenAPI specification.
+ * These functions work in any JavaScript environment.
+ *
+ * Features:
+ * - Runtime validation with Zod
+ * - Type-safe parameters and responses
+ * - Works with any data-fetching library (SWR, React Query, etc)
+ * - Server Component compatible
+ *
+ * Usage:
+ * ```typescript
+ * import * as fetchers from './fetchers'
+ *
+ * // Direct usage
+ * const user = await fetchers.getUser(1)
+ *
+ * // With SWR
+ * const { data } = useSWR('user-1', () => fetchers.getUser(1))
+ *
+ * // With React Query
+ * const { data } = useQuery(['user', 1], () => fetchers.getUser(1))
+ * ```
+ */
+
+declare const index_createKnowbaseAdminChatCreate: typeof createKnowbaseAdminChatCreate;
+declare const index_createKnowbaseAdminChatQueryCreate: typeof createKnowbaseAdminChatQueryCreate;
+declare const index_createKnowbaseAdminDocumentsCreate: typeof createKnowbaseAdminDocumentsCreate;
+declare const index_createKnowbaseAdminDocumentsReprocessCreate: typeof createKnowbaseAdminDocumentsReprocessCreate;
+declare const index_createKnowbaseAdminSessionsActivateCreate: typeof createKnowbaseAdminSessionsActivateCreate;
+declare const index_createKnowbaseAdminSessionsArchiveCreate: typeof createKnowbaseAdminSessionsArchiveCreate;
+declare const index_createKnowbaseAdminSessionsCreate: typeof createKnowbaseAdminSessionsCreate;
+declare const index_createKnowbaseSystemArchivesCreate: typeof createKnowbaseSystemArchivesCreate;
+declare const index_createKnowbaseSystemArchivesRevectorizeCreate: typeof createKnowbaseSystemArchivesRevectorizeCreate;
+declare const index_createKnowbaseSystemArchivesSearchCreate: typeof createKnowbaseSystemArchivesSearchCreate;
+declare const index_createKnowbaseSystemChunksCreate: typeof createKnowbaseSystemChunksCreate;
+declare const index_createKnowbaseSystemChunksVectorizeCreate: typeof createKnowbaseSystemChunksVectorizeCreate;
+declare const index_createKnowbaseSystemItemsCreate: typeof createKnowbaseSystemItemsCreate;
+declare const index_deleteKnowbaseAdminChatDestroy: typeof deleteKnowbaseAdminChatDestroy;
+declare const index_deleteKnowbaseAdminDocumentsDestroy: typeof deleteKnowbaseAdminDocumentsDestroy;
+declare const index_deleteKnowbaseAdminSessionsDestroy: typeof deleteKnowbaseAdminSessionsDestroy;
+declare const index_deleteKnowbaseSystemArchivesDestroy: typeof deleteKnowbaseSystemArchivesDestroy;
+declare const index_deleteKnowbaseSystemChunksDestroy: typeof deleteKnowbaseSystemChunksDestroy;
+declare const index_deleteKnowbaseSystemItemsDestroy: typeof deleteKnowbaseSystemItemsDestroy;
+declare const index_getKnowbaseAdminChatHistoryRetrieve: typeof getKnowbaseAdminChatHistoryRetrieve;
+declare const index_getKnowbaseAdminChatList: typeof getKnowbaseAdminChatList;
+declare const index_getKnowbaseAdminChatRetrieve: typeof getKnowbaseAdminChatRetrieve;
+declare const index_getKnowbaseAdminDocumentsList: typeof getKnowbaseAdminDocumentsList;
+declare const index_getKnowbaseAdminDocumentsRetrieve: typeof getKnowbaseAdminDocumentsRetrieve;
+declare const index_getKnowbaseAdminDocumentsStatsRetrieve: typeof getKnowbaseAdminDocumentsStatsRetrieve;
+declare const index_getKnowbaseAdminDocumentsStatusRetrieve: typeof getKnowbaseAdminDocumentsStatusRetrieve;
+declare const index_getKnowbaseAdminSessionsList: typeof getKnowbaseAdminSessionsList;
+declare const index_getKnowbaseAdminSessionsRetrieve: typeof getKnowbaseAdminSessionsRetrieve;
+declare const index_getKnowbaseCategoriesList: typeof getKnowbaseCategoriesList;
+declare const index_getKnowbaseCategoriesRetrieve: typeof getKnowbaseCategoriesRetrieve;
+declare const index_getKnowbaseDocumentsList: typeof getKnowbaseDocumentsList;
+declare const index_getKnowbaseDocumentsRetrieve: typeof getKnowbaseDocumentsRetrieve;
+declare const index_getKnowbaseSystemArchivesFileTreeRetrieve: typeof getKnowbaseSystemArchivesFileTreeRetrieve;
+declare const index_getKnowbaseSystemArchivesItemsList: typeof getKnowbaseSystemArchivesItemsList;
+declare const index_getKnowbaseSystemArchivesList: typeof getKnowbaseSystemArchivesList;
+declare const index_getKnowbaseSystemArchivesRetrieve: typeof getKnowbaseSystemArchivesRetrieve;
+declare const index_getKnowbaseSystemArchivesStatisticsRetrieve: typeof getKnowbaseSystemArchivesStatisticsRetrieve;
+declare const index_getKnowbaseSystemArchivesVectorizationStatsRetrieve: typeof getKnowbaseSystemArchivesVectorizationStatsRetrieve;
+declare const index_getKnowbaseSystemChunksContextRetrieve: typeof getKnowbaseSystemChunksContextRetrieve;
+declare const index_getKnowbaseSystemChunksList: typeof getKnowbaseSystemChunksList;
+declare const index_getKnowbaseSystemChunksRetrieve: typeof getKnowbaseSystemChunksRetrieve;
+declare const index_getKnowbaseSystemItemsChunksList: typeof getKnowbaseSystemItemsChunksList;
+declare const index_getKnowbaseSystemItemsContentRetrieve: typeof getKnowbaseSystemItemsContentRetrieve;
+declare const index_getKnowbaseSystemItemsList: typeof getKnowbaseSystemItemsList;
+declare const index_getKnowbaseSystemItemsRetrieve: typeof getKnowbaseSystemItemsRetrieve;
+declare const index_partialUpdateKnowbaseAdminChatPartialUpdate: typeof partialUpdateKnowbaseAdminChatPartialUpdate;
+declare const index_partialUpdateKnowbaseAdminDocumentsPartialUpdate: typeof partialUpdateKnowbaseAdminDocumentsPartialUpdate;
+declare const index_partialUpdateKnowbaseAdminSessionsPartialUpdate: typeof partialUpdateKnowbaseAdminSessionsPartialUpdate;
+declare const index_partialUpdateKnowbaseSystemArchivesPartialUpdate: typeof partialUpdateKnowbaseSystemArchivesPartialUpdate;
+declare const index_partialUpdateKnowbaseSystemChunksPartialUpdate: typeof partialUpdateKnowbaseSystemChunksPartialUpdate;
+declare const index_partialUpdateKnowbaseSystemItemsPartialUpdate: typeof partialUpdateKnowbaseSystemItemsPartialUpdate;
+declare const index_updateKnowbaseAdminChatUpdate: typeof updateKnowbaseAdminChatUpdate;
+declare const index_updateKnowbaseAdminDocumentsUpdate: typeof updateKnowbaseAdminDocumentsUpdate;
+declare const index_updateKnowbaseAdminSessionsUpdate: typeof updateKnowbaseAdminSessionsUpdate;
+declare const index_updateKnowbaseSystemArchivesUpdate: typeof updateKnowbaseSystemArchivesUpdate;
+declare const index_updateKnowbaseSystemChunksUpdate: typeof updateKnowbaseSystemChunksUpdate;
+declare const index_updateKnowbaseSystemItemsUpdate: typeof updateKnowbaseSystemItemsUpdate;
+declare namespace index {
+  export { index_createKnowbaseAdminChatCreate as createKnowbaseAdminChatCreate, index_createKnowbaseAdminChatQueryCreate as createKnowbaseAdminChatQueryCreate, index_createKnowbaseAdminDocumentsCreate as createKnowbaseAdminDocumentsCreate, index_createKnowbaseAdminDocumentsReprocessCreate as createKnowbaseAdminDocumentsReprocessCreate, index_createKnowbaseAdminSessionsActivateCreate as createKnowbaseAdminSessionsActivateCreate, index_createKnowbaseAdminSessionsArchiveCreate as createKnowbaseAdminSessionsArchiveCreate, index_createKnowbaseAdminSessionsCreate as createKnowbaseAdminSessionsCreate, index_createKnowbaseSystemArchivesCreate as createKnowbaseSystemArchivesCreate, index_createKnowbaseSystemArchivesRevectorizeCreate as createKnowbaseSystemArchivesRevectorizeCreate, index_createKnowbaseSystemArchivesSearchCreate as createKnowbaseSystemArchivesSearchCreate, index_createKnowbaseSystemChunksCreate as createKnowbaseSystemChunksCreate, index_createKnowbaseSystemChunksVectorizeCreate as createKnowbaseSystemChunksVectorizeCreate, index_createKnowbaseSystemItemsCreate as createKnowbaseSystemItemsCreate, index_deleteKnowbaseAdminChatDestroy as deleteKnowbaseAdminChatDestroy, index_deleteKnowbaseAdminDocumentsDestroy as deleteKnowbaseAdminDocumentsDestroy, index_deleteKnowbaseAdminSessionsDestroy as deleteKnowbaseAdminSessionsDestroy, index_deleteKnowbaseSystemArchivesDestroy as deleteKnowbaseSystemArchivesDestroy, index_deleteKnowbaseSystemChunksDestroy as deleteKnowbaseSystemChunksDestroy, index_deleteKnowbaseSystemItemsDestroy as deleteKnowbaseSystemItemsDestroy, index_getKnowbaseAdminChatHistoryRetrieve as getKnowbaseAdminChatHistoryRetrieve, index_getKnowbaseAdminChatList as getKnowbaseAdminChatList, index_getKnowbaseAdminChatRetrieve as getKnowbaseAdminChatRetrieve, index_getKnowbaseAdminDocumentsList as getKnowbaseAdminDocumentsList, index_getKnowbaseAdminDocumentsRetrieve as getKnowbaseAdminDocumentsRetrieve, index_getKnowbaseAdminDocumentsStatsRetrieve as getKnowbaseAdminDocumentsStatsRetrieve, index_getKnowbaseAdminDocumentsStatusRetrieve as getKnowbaseAdminDocumentsStatusRetrieve, index_getKnowbaseAdminSessionsList as getKnowbaseAdminSessionsList, index_getKnowbaseAdminSessionsRetrieve as getKnowbaseAdminSessionsRetrieve, index_getKnowbaseCategoriesList as getKnowbaseCategoriesList, index_getKnowbaseCategoriesRetrieve as getKnowbaseCategoriesRetrieve, index_getKnowbaseDocumentsList as getKnowbaseDocumentsList, index_getKnowbaseDocumentsRetrieve as getKnowbaseDocumentsRetrieve, index_getKnowbaseSystemArchivesFileTreeRetrieve as getKnowbaseSystemArchivesFileTreeRetrieve, index_getKnowbaseSystemArchivesItemsList as getKnowbaseSystemArchivesItemsList, index_getKnowbaseSystemArchivesList as getKnowbaseSystemArchivesList, index_getKnowbaseSystemArchivesRetrieve as getKnowbaseSystemArchivesRetrieve, index_getKnowbaseSystemArchivesStatisticsRetrieve as getKnowbaseSystemArchivesStatisticsRetrieve, index_getKnowbaseSystemArchivesVectorizationStatsRetrieve as getKnowbaseSystemArchivesVectorizationStatsRetrieve, index_getKnowbaseSystemChunksContextRetrieve as getKnowbaseSystemChunksContextRetrieve, index_getKnowbaseSystemChunksList as getKnowbaseSystemChunksList, index_getKnowbaseSystemChunksRetrieve as getKnowbaseSystemChunksRetrieve, index_getKnowbaseSystemItemsChunksList as getKnowbaseSystemItemsChunksList, index_getKnowbaseSystemItemsContentRetrieve as getKnowbaseSystemItemsContentRetrieve, index_getKnowbaseSystemItemsList as getKnowbaseSystemItemsList, index_getKnowbaseSystemItemsRetrieve as getKnowbaseSystemItemsRetrieve, index_partialUpdateKnowbaseAdminChatPartialUpdate as partialUpdateKnowbaseAdminChatPartialUpdate, index_partialUpdateKnowbaseAdminDocumentsPartialUpdate as partialUpdateKnowbaseAdminDocumentsPartialUpdate, index_partialUpdateKnowbaseAdminSessionsPartialUpdate as partialUpdateKnowbaseAdminSessionsPartialUpdate, index_partialUpdateKnowbaseSystemArchivesPartialUpdate as partialUpdateKnowbaseSystemArchivesPartialUpdate, index_partialUpdateKnowbaseSystemChunksPartialUpdate as partialUpdateKnowbaseSystemChunksPartialUpdate, index_partialUpdateKnowbaseSystemItemsPartialUpdate as partialUpdateKnowbaseSystemItemsPartialUpdate, index_updateKnowbaseAdminChatUpdate as updateKnowbaseAdminChatUpdate, index_updateKnowbaseAdminDocumentsUpdate as updateKnowbaseAdminDocumentsUpdate, index_updateKnowbaseAdminSessionsUpdate as updateKnowbaseAdminSessionsUpdate, index_updateKnowbaseSystemArchivesUpdate as updateKnowbaseSystemArchivesUpdate, index_updateKnowbaseSystemChunksUpdate as updateKnowbaseSystemChunksUpdate, index_updateKnowbaseSystemItemsUpdate as updateKnowbaseSystemItemsUpdate };
+}
+
+/**
+ * Global API Instance - Singleton configuration
+ *
+ * This module provides a global API instance that can be configured once
+ * and used throughout your application.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure once (e.g., in your app entry point)
+ * import { configureAPI } from './api-instance'
+ *
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'your-jwt-token'
+ * })
+ *
+ * // Then use fetchers and hooks anywhere without configuration
+ * import { getUsers } from './fetchers'
+ * const users = await getUsers({ page: 1 })
+ * ```
+ *
+ * For SSR or multiple instances:
+ * ```typescript
+ * import { API } from './index'
+ * import { getUsers } from './fetchers'
+ *
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+
+/**
+ * Get the global API instance
+ * @throws Error if API is not configured
+ */
+declare function getAPIInstance(): API;
+/**
+ * Check if API is configured
+ */
+declare function isAPIConfigured(): boolean;
+/**
+ * Configure the global API instance
+ *
+ * @param baseUrl - Base URL for the API
+ * @param options - Optional configuration (storage, retry, logger)
+ *
+ * @example
+ * ```typescript
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'jwt-token',
+ *   options: {
+ *     retryConfig: { maxRetries: 3 },
+ *     loggerConfig: { enabled: true }
+ *   }
+ * })
+ * ```
+ */
+declare function configureAPI(config: {
+    baseUrl: string;
+    token?: string;
+    refreshToken?: string;
+    options?: APIOptions;
+}): API;
+/**
+ * Reconfigure the global API instance with new settings
+ * Useful for updating tokens or base URL
+ */
+declare function reconfigureAPI(updates: {
+    baseUrl?: string;
+    token?: string;
+    refreshToken?: string;
+}): API;
+/**
+ * Clear tokens from the global API instance
+ */
+declare function clearAPITokens(): void;
+/**
+ * Reset the global API instance
+ * Useful for testing or logout scenarios
+ */
+declare function resetAPI(): void;
+
+/**
+ * API Error Classes
+ *
+ * Typed error classes with Django REST Framework support.
+ */
+/**
+ * HTTP API Error with DRF field-specific validation errors.
+ *
+ * Usage:
+ * ```typescript
+ * try {
+ *   await api.users.create(userData);
+ * } catch (error) {
+ *   if (error instanceof APIError) {
+ *     if (error.isValidationError) {
+ *       console.log('Field errors:', error.fieldErrors);
+ *       // { "email": ["Email already exists"], "username": ["Required"] }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+declare class APIError extends Error {
+    statusCode: number;
+    statusText: string;
+    response: any;
+    url: string;
+    constructor(statusCode: number, statusText: string, response: any, url: string, message?: string);
+    /**
+     * Get error details from response.
+     * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+     */
+    get details(): Record<string, any> | null;
+    /**
+     * Get field-specific validation errors from DRF.
+     * Returns: { "field_name": ["error1", "error2"], ... }
+     */
+    get fieldErrors(): Record<string, string[]> | null;
+    /**
+     * Get single error message from DRF.
+     * Checks for "detail", "message", or first field error.
+     */
+    get errorMessage(): string;
+    get isValidationError(): boolean;
+    get isAuthError(): boolean;
+    get isPermissionError(): boolean;
+    get isNotFoundError(): boolean;
+    get isServerError(): boolean;
+}
+/**
+ * Network Error (connection failed, timeout, etc.)
+ */
+declare class NetworkError extends Error {
+    url: string;
+    originalError?: Error;
+    constructor(message: string, url: string, originalError?: Error);
+}
+
+/**
+ * Django CFG API - API Client with JWT Management
+ *
+ * Usage:
+ * ```typescript
+ * import { API } from './api';
+ *
+ * const api = new API('https://api.example.com');
+ *
+ * // Set JWT token
+ * api.setToken('your-jwt-token', 'refresh-token');
+ *
+ * // Use API
+ * const posts = await api.posts.list();
+ * const user = await api.users.retrieve(1);
+ *
+ * // Check authentication
+ * if (api.isAuthenticated()) {
+ *   // ...
+ * }
+ *
+ * // Custom storage with logging (for Electron/Node.js)
+ * import { MemoryStorageAdapter, APILogger } from './storage';
+ * const logger = new APILogger({ enabled: true, logLevel: 'debug' });
+ * const api = new API('https://api.example.com', {
+ *   storage: new MemoryStorageAdapter(logger),
+ *   loggerConfig: { enabled: true, logLevel: 'debug' }
+ * });
+ *
+ * // Get OpenAPI schema
+ * const schema = api.getSchema();
+ * ```
+ */
+
+declare const TOKEN_KEY = "auth_token";
+declare const REFRESH_TOKEN_KEY = "refresh_token";
+interface APIOptions {
+    /** Custom storage adapter (defaults to LocalStorageAdapter) */
+    storage?: StorageAdapter;
+    /** Retry configuration for failed requests */
+    retryConfig?: RetryConfig;
+    /** Logger configuration */
+    loggerConfig?: Partial<LoggerConfig>;
+}
+declare class API {
+    private baseUrl;
+    private _client;
+    private _token;
+    private _refreshToken;
+    private storage;
+    private options?;
+    ext_knowbase_knowbase: ExtKnowbaseKnowbase;
+    constructor(baseUrl: string, options?: APIOptions);
+    private _loadTokensFromStorage;
+    private _reinitClients;
+    private _injectAuthHeader;
+    /**
+     * Get current JWT token
+     */
+    getToken(): string | null;
+    /**
+     * Get current refresh token
+     */
+    getRefreshToken(): string | null;
+    /**
+     * Set JWT token and refresh token
+     * @param token - JWT access token
+     * @param refreshToken - JWT refresh token (optional)
+     */
+    setToken(token: string, refreshToken?: string): void;
+    /**
+     * Clear all tokens
+     */
+    clearTokens(): void;
+    /**
+     * Check if user is authenticated
+     */
+    isAuthenticated(): boolean;
+    /**
+     * Update base URL and reinitialize clients
+     * @param url - New base URL
+     */
+    setBaseUrl(url: string): void;
+    /**
+     * Get current base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Get OpenAPI schema path
+     * @returns Path to the OpenAPI schema JSON file
+     *
+     * Note: The OpenAPI schema is available in the schema.json file.
+     * You can load it dynamically using:
+     * ```typescript
+     * const schema = await fetch('./schema.json').then(r => r.json());
+     * // or using fs in Node.js:
+     * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+     * ```
+     */
+    getSchemaPath(): string;
+}
+
+/**
+ * Knowbase Extension API
+ *
+ * Pre-configured API instance with shared authentication
+ */
+
+declare const apiKnowbase: API;
+
+/**
+ * Chat Types
+ * Type definitions for RAG-powered chat widget
+ */
+
+type ChatMessage = ChatMessage$2;
+type ChatSource = ChatSource$2;
+interface ChatMessageWithSources extends ChatMessage {
+    sources?: ChatSource[];
+}
+interface ChatWidgetProps {
+    /** Whether to auto-open on mount */
+    autoOpen?: boolean;
+    /** Render even when closed (for animations) */
+    persistent?: boolean;
+    /** Additional CSS classes */
+    className?: string;
+    /** Callback when toggle state changes */
+    onToggle?: (isOpen: boolean) => void;
+    /** Callback when message is sent */
+    onMessage?: (message: ChatMessageWithSources) => void;
+}
+interface ChatUIState {
+    isOpen: boolean;
+    isExpanded: boolean;
+    isMinimized: boolean;
+    showSources: boolean;
+    showTimestamps: boolean;
+}
+interface MessageListProps {
+    messages: ChatMessageWithSources[];
+    isLoading?: boolean;
+    showSources?: boolean;
+    showTimestamps?: boolean;
+    autoScroll?: boolean;
+    className?: string;
+}
+interface MessageInputProps {
+    onSend: (message: string) => Promise<void>;
+    isLoading?: boolean;
+    disabled?: boolean;
+    placeholder?: string;
+    className?: string;
+}
+interface SessionListProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onSelectSession: (sessionId: string) => void;
+    className?: string;
+}
+
+/**
+ * Knowledge Base extension configuration
+ */
+declare const extensionConfig: _djangocfg_ext_base.ExtensionMetadata;
+
+export { API, APIClient, APIError, APILogger, type APIOptions, type ArchiveItem, type ArchiveItemChunk, type ArchiveItemChunkDetail, ArchiveItemChunkDetailSchema, type ArchiveItemChunkRequest, ArchiveItemChunkRequestSchema, ArchiveItemChunkSchema, type ArchiveItemDetail, ArchiveItemDetailSchema, type ArchiveItemRequest, ArchiveItemRequestSchema, ArchiveItemSchema, type ArchiveProcessingResult, ArchiveProcessingResultSchema, type ArchiveSearchRequestRequest, ArchiveSearchRequestRequestSchema, type ArchiveSearchResult, ArchiveSearchResultSchema, type ArchiveStatistics, ArchiveStatisticsSchema, type ChatHistory, ChatHistorySchema, type ChatMessage$1 as ChatMessage, ChatMessageSchema, type ChatMessageWithSources, type ChatQueryRequest, ChatQueryRequestSchema, type ChatResponse, type ChatResponseRequest, ChatResponseRequestSchema, ChatResponseSchema, type ChatSession, type ChatSessionCreateRequest, ChatSessionCreateRequestSchema, type ChatSessionRequest, ChatSessionRequestSchema, ChatSessionSchema, type ChatSource$1 as ChatSource, type ChatSourceRequest, ChatSourceRequestSchema, ChatSourceSchema, type ChatUIState, type ChatWidgetProps, type ChunkRevectorizationRequestRequest, ChunkRevectorizationRequestRequestSchema, CookieStorageAdapter, DEFAULT_RETRY_CONFIG, type Document, type DocumentArchive, type DocumentArchiveDetail, DocumentArchiveDetailSchema, type DocumentArchiveList, DocumentArchiveListSchema, type DocumentArchiveRequest, DocumentArchiveRequestSchema, DocumentArchiveSchema, type DocumentCategory, type DocumentCategoryRequest, DocumentCategoryRequestSchema, DocumentCategorySchema, type DocumentCreateRequest, DocumentCreateRequestSchema, type DocumentProcessingStatus, DocumentProcessingStatusSchema, type DocumentRequest, DocumentRequestSchema, DocumentSchema, type DocumentStats, DocumentStatsSchema, GeneratedEnums as Enums, type ErrorLog, models as ExtKnowbaseKnowbaseTypes, type FailedAttemptInfo, FetchAdapter, index as Fetchers, type HttpClientAdapter, type HttpRequest, type HttpResponse, LocalStorageAdapter, type LoggerConfig, MemoryStorageAdapter, type MessageInputProps, type MessageListProps, NetworkError, type PaginatedArchiveItemChunkList, PaginatedArchiveItemChunkListSchema, type PaginatedArchiveItemList, PaginatedArchiveItemListSchema, type PaginatedArchiveSearchResultList, PaginatedArchiveSearchResultListSchema, type PaginatedChatResponseList, PaginatedChatResponseListSchema, type PaginatedChatSessionList, PaginatedChatSessionListSchema, type PaginatedDocumentArchiveListList, PaginatedDocumentArchiveListListSchema, type PaginatedDocumentList, PaginatedDocumentListSchema, type PaginatedPublicCategoryList, PaginatedPublicCategoryListSchema, type PaginatedPublicDocumentListList, PaginatedPublicDocumentListListSchema, type PatchedArchiveItemChunkRequest, PatchedArchiveItemChunkRequestSchema, type PatchedArchiveItemRequest, PatchedArchiveItemRequestSchema, type PatchedChatResponseRequest, PatchedChatResponseRequestSchema, type PatchedChatSessionRequest, PatchedChatSessionRequestSchema, type PatchedDocumentArchiveRequest, PatchedDocumentArchiveRequestSchema, type PatchedDocumentRequest, PatchedDocumentRequestSchema, type PublicCategory, PublicCategorySchema, type PublicDocument, type PublicDocumentList, PublicDocumentListSchema, PublicDocumentSchema, REFRESH_TOKEN_KEY, type RequestLog, type ResponseLog, type RetryConfig, index$1 as Schemas, type SessionListProps, type StorageAdapter, TOKEN_KEY, type ValidationErrorDetail, type ValidationErrorEvent, type VectorizationResult, VectorizationResultSchema, type VectorizationStatistics, VectorizationStatisticsSchema, apiKnowbase, clearAPITokens, configureAPI, createKnowbaseAdminChatCreate, createKnowbaseAdminChatQueryCreate, createKnowbaseAdminDocumentsCreate, createKnowbaseAdminDocumentsReprocessCreate, createKnowbaseAdminSessionsActivateCreate, createKnowbaseAdminSessionsArchiveCreate, createKnowbaseAdminSessionsCreate, createKnowbaseSystemArchivesCreate, createKnowbaseSystemArchivesRevectorizeCreate, createKnowbaseSystemArchivesSearchCreate, createKnowbaseSystemChunksCreate, createKnowbaseSystemChunksVectorizeCreate, createKnowbaseSystemItemsCreate, deleteKnowbaseAdminChatDestroy, deleteKnowbaseAdminDocumentsDestroy, deleteKnowbaseAdminSessionsDestroy, deleteKnowbaseSystemArchivesDestroy, deleteKnowbaseSystemChunksDestroy, deleteKnowbaseSystemItemsDestroy, dispatchValidationError, extensionConfig, formatZodError, getAPIInstance, getKnowbaseAdminChatHistoryRetrieve, getKnowbaseAdminChatList, getKnowbaseAdminChatRetrieve, getKnowbaseAdminDocumentsList, getKnowbaseAdminDocumentsRetrieve, getKnowbaseAdminDocumentsStatsRetrieve, getKnowbaseAdminDocumentsStatusRetrieve, getKnowbaseAdminSessionsList, getKnowbaseAdminSessionsRetrieve, getKnowbaseCategoriesList, getKnowbaseCategoriesRetrieve, getKnowbaseDocumentsList, getKnowbaseDocumentsRetrieve, getKnowbaseSystemArchivesFileTreeRetrieve, getKnowbaseSystemArchivesItemsList, getKnowbaseSystemArchivesList, getKnowbaseSystemArchivesRetrieve, getKnowbaseSystemArchivesStatisticsRetrieve, getKnowbaseSystemArchivesVectorizationStatsRetrieve, getKnowbaseSystemChunksContextRetrieve, getKnowbaseSystemChunksList, getKnowbaseSystemChunksRetrieve, getKnowbaseSystemItemsChunksList, getKnowbaseSystemItemsContentRetrieve, getKnowbaseSystemItemsList, getKnowbaseSystemItemsRetrieve, isAPIConfigured, onValidationError, partialUpdateKnowbaseAdminChatPartialUpdate, partialUpdateKnowbaseAdminDocumentsPartialUpdate, partialUpdateKnowbaseAdminSessionsPartialUpdate, partialUpdateKnowbaseSystemArchivesPartialUpdate, partialUpdateKnowbaseSystemChunksPartialUpdate, partialUpdateKnowbaseSystemItemsPartialUpdate, reconfigureAPI, resetAPI, shouldRetry, updateKnowbaseAdminChatUpdate, updateKnowbaseAdminDocumentsUpdate, updateKnowbaseAdminSessionsUpdate, updateKnowbaseSystemArchivesUpdate, updateKnowbaseSystemChunksUpdate, updateKnowbaseSystemItemsUpdate, withRetry };