captify 0.1.18 → 1.1.0

package/dist/search/search.constants.d.ts

@@ -0,0 +1,1230 @@
+/**
+ * Search Module Constants
+ *
+ * Routes, result types, defaults, and index names for the global unified search feature.
+ */
+import type { LucideIcon } from "lucide-react";
+import type { ComponentSearchTab, SearchTab } from "./search.interfaces";
+/**
+ * API routes for search endpoints
+ */
+export declare const SEARCH_ROUTES: {
+    readonly SEARCH: "/api/search";
+    readonly LOCK_EVENTS: "/api/search/locks/events";
+};
+/**
+ * Searchable result types
+ */
+export declare const SEARCH_RESULT_TYPES: readonly ["document", "user", "group", "agent", "feedback", "chat", "message"];
+/**
+ * Search configuration defaults
+ */
+export declare const SEARCH_DEFAULTS: {
+    /** Minimum query length required to perform search */
+    readonly MIN_QUERY_LENGTH: 2;
+    /** Maximum query length allowed */
+    readonly MAX_QUERY_LENGTH: 500;
+    /** Default number of results per page */
+    readonly DEFAULT_LIMIT: 10;
+    /** Maximum results per page */
+    readonly MAX_LIMIT: 50;
+    /** Debounce delay in milliseconds */
+    readonly DEBOUNCE_MS: 600;
+    /** Maximum recent searches to store */
+    readonly MAX_RECENT_SEARCHES: 5;
+};
+/**
+ * OpenSearch index names for each entity type
+ */
+export declare const SEARCH_INDEX_NAMES: {
+    readonly DOCUMENTS: "captify-search-documents";
+    readonly USERS: "captify-search-users";
+    readonly GROUPS: "captify-search-groups";
+    readonly AGENTS: "captify-search-agents";
+    readonly FEEDBACKS: "captify-search-feedbacks";
+    readonly CHATS: "captify-search-chats";
+    readonly MESSAGES: "captify-search-messages";
+};
+/**
+ * All search index names as an array
+ */
+export declare const ALL_SEARCH_INDICES: ("captify-search-documents" | "captify-search-users" | "captify-search-groups" | "captify-search-agents" | "captify-search-feedbacks" | "captify-search-chats" | "captify-search-messages")[];
+/**
+ * Index name to result type mapping
+ */
+export declare const INDEX_TO_TYPE_MAP: Record<string, (typeof SEARCH_RESULT_TYPES)[number]>;
+/**
+ * Result type to index name mapping
+ */
+export declare const TYPE_TO_INDEX_MAP: Record<(typeof SEARCH_RESULT_TYPES)[number], string>;
+/**
+ * Display labels for result types (used in search result category badges)
+ */
+export declare const SEARCH_CATEGORY_LABELS: Record<(typeof SEARCH_RESULT_TYPES)[number], string>;
+/**
+ * Icon names for result types (Lucide icons)
+ */
+export declare const SEARCH_CATEGORY_ICONS: Record<(typeof SEARCH_RESULT_TYPES)[number], string>;
+/**
+ * Default placeholder URL when no page exists yet
+ */
+export declare const NO_PAGE_PLACEHOLDER: "#";
+/**
+ * URL patterns for navigation to search results.
+ * Use buildSearchResultHref() utility to generate actual URLs from these patterns.
+ */
+export declare const SEARCH_URL_PATTERNS: Record<(typeof SEARCH_RESULT_TYPES)[number], string>;
+/**
+ * Default search tabs configuration
+ */
+export declare const DEFAULT_SEARCH_TABS: SearchTab[];
+/**
+ * LocalStorage keys for search persistence
+ */
+export declare const SEARCH_STORAGE_KEYS: {
+    readonly RECENT_SEARCHES: "captify-core:global-search-recent";
+    readonly TAB_SETTINGS: "captify-core:global-search-tab-settings";
+};
+/**
+ * Query cache configuration for React Query/TanStack Query
+ */
+export declare const SEARCH_QUERY_CONFIG: {
+    /** How long results are considered fresh (30 seconds) */
+    readonly STALE_TIME_MS: number;
+    /** How long to keep results in cache after unused (5 minutes) */
+    readonly GC_TIME_MS: number;
+    /** Number of retry attempts for failed queries */
+    readonly RETRY_COUNT: 2;
+    /** Maximum retry delay in milliseconds */
+    readonly MAX_RETRY_DELAY_MS: 10000;
+    /** Base delay multiplier for exponential backoff */
+    readonly RETRY_DELAY_BASE_MS: 1000;
+};
+/**
+ * Index health status values
+ */
+export declare const INDEX_HEALTH_STATUS: {
+    readonly GREEN: "green";
+    readonly YELLOW: "yellow";
+    readonly RED: "red";
+};
+export type IndexHealthStatus = (typeof INDEX_HEALTH_STATUS)[keyof typeof INDEX_HEALTH_STATUS];
+/**
+ * Error codes for search operations
+ */
+export declare const SEARCH_ERROR_CODES: {
+    readonly INVALID_QUERY: "INVALID_QUERY";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly OPENSEARCH_ERROR: "OPENSEARCH_ERROR";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+};
+/**
+ * Error messages for search operations
+ */
+export declare const SEARCH_ERROR_MESSAGES: {
+    readonly QUERY_TOO_SHORT: "Query must be at least 2 characters";
+    readonly QUERY_TOO_LONG: "Query must not exceed 500 characters";
+    readonly SERVICE_UNAVAILABLE: "Search service is temporarily unavailable";
+    readonly UNAUTHORIZED: "Authentication required";
+    readonly INVALID_TYPE: "Invalid search type filter";
+    readonly OPENSEARCH_CONNECTION_FAILED: "Failed to connect to search service";
+    readonly SYNC_INDEX_FAILED: "An error occurred while syncing the index";
+    readonly SYNC_DOCUMENTS_FAILED: "Error syncing documents — check logs for details";
+    readonly SYNC_AGENTS_FAILED: "Error syncing agents — check logs for details";
+    readonly SYNC_FEEDBACKS_FAILED: "Error syncing feedbacks — check logs for details";
+    readonly SYNC_CHATS_FAILED: "Error syncing chats — check logs for details";
+    readonly SYNC_MESSAGES_FAILED: "Error syncing messages — check logs for details";
+    readonly SYNC_USERS_FAILED: "Error syncing users — check logs for details";
+    readonly SYNC_GROUPS_FAILED: "Error syncing groups — check logs for details";
+};
+/**
+ * Indices that support sync operations
+ */
+export declare const SYNCABLE_INDICES: readonly ["captify-search-documents", "captify-search-agents", "captify-search-feedbacks", "captify-search-chats", "captify-search-messages", "captify-search-users", "captify-search-groups"];
+/**
+ * OpenSearch error messages
+ */
+export declare const OPENSEARCH_ERROR_MESSAGES: {
+    readonly ENDPOINT_REQUIRED: "OpenSearch endpoint is required";
+    readonly REGION_REQUIRED: "AWS region is required for OpenSearch";
+    readonly CONNECTION_FAILED: "Failed to connect to OpenSearch";
+    readonly ACCESS_KEY_REQUIRED: "AWS access key ID is required";
+    readonly SECRET_KEY_REQUIRED: "AWS secret access key is required";
+    readonly INVALID_INDEX_DELETION: "Cannot delete index: only captify-managed search indices can be deleted";
+    readonly INDEX_CREATION_FAILED: "An error occurred while creating the index";
+};
+/**
+ * Embedding error messages
+ */
+export declare const EMBEDDING_ERROR_MESSAGES: {
+    readonly EMPTY_TEXT: "Cannot generate embedding for empty text - check upstream document content extraction";
+};
+/**
+ * Network error codes that indicate connection/availability issues
+ */
+export declare const NETWORK_ERROR_CODES: {
+    readonly CONNECTION_REFUSED: "ECONNREFUSED";
+    readonly TIMEOUT: "ETIMEDOUT";
+    readonly NOT_FOUND: "ENOTFOUND";
+    readonly UNAVAILABLE: "unavailable";
+};
+/**
+ * OpenSearch default configuration values
+ */
+export declare const OPENSEARCH_DEFAULT_CONFIG: {
+    /** Default request timeout in milliseconds */
+    readonly REQUEST_TIMEOUT_MS: 30000;
+    /** AWS service name for OpenSearch SigV4 signing */
+    readonly AWS_SERVICE_NAME: "es";
+    /** User client cache TTL in milliseconds (5 minutes) */
+    readonly USER_CLIENT_TTL_MS: number;
+    /** Interval for periodic cleanup of stale user clients (1 minute) */
+    readonly USER_CLIENT_CLEANUP_INTERVAL_MS: number;
+    /** Maximum number of cached user clients (LRU eviction when exceeded) */
+    readonly USER_CLIENT_MAX_CACHE_SIZE: 100;
+    /** Default wildcard pattern for index searches */
+    readonly DEFAULT_INDEX_PATTERN: "*";
+    /** Default document count when unavailable */
+    readonly DEFAULT_DOCS_COUNT: "0";
+    /** Default number of primary shards for new indices */
+    readonly DEFAULT_NUMBER_OF_SHARDS: 1;
+    /** Default number of replicas for new indices */
+    readonly DEFAULT_NUMBER_OF_REPLICAS: 1;
+    /** Maximum number of retries for failed requests */
+    readonly MAX_RETRIES: 3;
+    /**
+     * Resurrection strategy for dead connections.
+     * 'optimistic' = immediately try dead nodes on next request (best for AWS OpenSearch)
+     * 'ping' = periodically ping dead nodes to check if alive
+     * 'none' = never resurrect dead nodes
+     *
+     * AWS OpenSearch provides a single endpoint URL that load-balances to the cluster.
+     * Using 'optimistic' ensures transient failures don't permanently mark the endpoint as dead.
+     */
+    readonly RESURRECT_STRATEGY: "optimistic";
+};
+/**
+ * OpenSearch query cache configuration for index-level caching.
+ *
+ * Trade-offs:
+ * - QUERY_CACHE_ENABLED: Caches filter query results. Improves performance for repeated
+ *   queries but uses memory. Recommended for read-heavy workloads.
+ * - REFRESH_INTERVAL: Controls how often new documents become searchable.
+ *   - Lower values (1s): Near real-time search, higher I/O overhead
+ *   - Higher values (30s+): Better indexing performance, stale search results
+ *   - 5s is a balanced default for most use cases with moderate update frequency
+ *
+ * These settings are applied at index creation time. To modify existing indices,
+ * use the OpenSearch Update Settings API or recreate the index.
+ *
+ * @see https://opensearch.org/docs/latest/install-and-configure/configuring-opensearch/index-settings/
+ */
+export declare const OPENSEARCH_CACHE_CONFIG: {
+    /**
+     * Enable query cache for filter results.
+     * Caches results of filter queries to speed up repeated searches.
+     */
+    readonly QUERY_CACHE_ENABLED: true;
+    /**
+     * How often the index refreshes to make new documents searchable.
+     * 5s balances search freshness with indexing performance.
+     */
+    readonly REFRESH_INTERVAL: "5s";
+};
+/**
+ * Titan Embedding model configuration
+ * - titan-embed-text-v1: 1536 dimensions
+ * - titan-embed-text-v2:0: 1024 dimensions (default), configurable
+ */
+export declare const EMBEDDING_CONFIG: {
+    /** Model ID for Amazon Titan Embeddings */
+    readonly MODEL_ID: "amazon.titan-embed-text-v2:0";
+    /** Number of embedding dimensions */
+    readonly DIMENSIONS: 1024;
+    /** Maximum text length before truncation (Titan has 8k token limit) */
+    readonly MAX_TEXT_LENGTH: 50000;
+    /** Concurrency limit for batch embedding operations */
+    readonly BATCH_CONCURRENCY: 5;
+};
+/**
+ * Embedding cache configuration for LRU cache
+ */
+export declare const EMBEDDING_CACHE_CONFIG: {
+    /** Maximum number of cached embeddings (~4MB at 4KB per entry) */
+    readonly MAX_CACHE_SIZE: 1000;
+    /** Time-to-live for cached embeddings in milliseconds (5 minutes) */
+    readonly TTL_MS: number;
+    /** Maximum cache key length for normalization */
+    readonly CACHE_KEY_MAX_LENGTH: 200;
+};
+/**
+ * Index schema version for migration tracking.
+ * Increment minor version for backward-compatible changes (new optional fields).
+ * Increment major version for breaking changes (removed fields, type changes).
+ */
+export declare const INDEX_SCHEMA_VERSION: {
+    /** Current schema version for all indices */
+    readonly CURRENT: "1.0";
+    /** Initial version when versioning was introduced */
+    readonly INITIAL: "1.0";
+};
+/**
+ * k-NN settings for vector fields (using faiss engine with cosinesimil for OpenSearch 2.19.0+)
+ */
+export declare const KNN_VECTOR_FIELD: {
+    readonly type: "knn_vector";
+    readonly dimension: 1024;
+    readonly method: {
+        readonly name: "hnsw";
+        readonly space_type: "cosinesimil";
+        readonly engine: "faiss";
+        readonly parameters: {
+            readonly ef_construction: 128;
+            readonly m: 16;
+        };
+    };
+};
+/**
+ * Common index settings applied to all search indices.
+ * Combines k-NN support with query cache configuration for optimal performance.
+ */
+export declare const COMMON_INDEX_SETTINGS: {
+    readonly "index.knn": true;
+    readonly "index.queries.cache.enabled": true;
+    readonly refresh_interval: "5s";
+};
+/**
+ * OpenSearch index definitions with mappings for all searchable entity types.
+ * Each definition includes a version number for schema migration support.
+ */
+export declare const INDEX_DEFINITIONS: readonly [{
+    readonly name: "captify-search-documents";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly documentId: {
+                readonly type: "keyword";
+            };
+            readonly parentId: {
+                readonly type: "keyword";
+            };
+            readonly chunkIndex: {
+                readonly type: "integer";
+            };
+            readonly totalChunks: {
+                readonly type: "integer";
+            };
+            readonly title: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly originalName: {
+                readonly type: "keyword";
+            };
+            readonly description: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly content: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly userId: {
+                readonly type: "keyword";
+            };
+            readonly bucket: {
+                readonly type: "keyword";
+            };
+            readonly key: {
+                readonly type: "keyword";
+            };
+            readonly size: {
+                readonly type: "long";
+            };
+            readonly lastModified: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    readonly name: "captify-search-users";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly name: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly displayName: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly email: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly enabled: {
+                readonly type: "boolean";
+            };
+            readonly status: {
+                readonly type: "keyword";
+            };
+            readonly department: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly jobTitle: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly roles: {
+                readonly type: "keyword";
+            };
+            readonly createdAt: {
+                readonly type: "date";
+            };
+            readonly updatedAt: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    readonly name: "captify-search-groups";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly name: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly displayName: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly description: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly createdAt: {
+                readonly type: "date";
+            };
+            readonly updatedAt: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    readonly name: "captify-search-agents";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly name: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly title: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly description: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly instructions: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly status: {
+                readonly type: "keyword";
+            };
+            readonly createdAt: {
+                readonly type: "date";
+            };
+            readonly updatedAt: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    readonly name: "captify-search-feedbacks";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly title: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly description: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly content: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly userId: {
+                readonly type: "keyword";
+            };
+            readonly status: {
+                readonly type: "keyword";
+            };
+            readonly createdAt: {
+                readonly type: "date";
+            };
+            readonly updatedAt: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    readonly name: "captify-search-chats";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly title: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly description: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly userId: {
+                readonly type: "keyword";
+            };
+            readonly messageCount: {
+                readonly type: "integer";
+            };
+            readonly isArchived: {
+                readonly type: "boolean";
+            };
+            readonly createdAt: {
+                readonly type: "date";
+            };
+            readonly updatedAt: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    readonly name: "captify-search-messages";
+    readonly version: "1.0";
+    readonly settings: {
+        readonly "index.knn": true;
+        readonly "index.queries.cache.enabled": true;
+        readonly refresh_interval: "5s";
+    };
+    readonly mappings: {
+        readonly properties: {
+            readonly id: {
+                readonly type: "keyword";
+            };
+            readonly collapseId: {
+                readonly type: "keyword";
+            };
+            readonly sessionId: {
+                readonly type: "keyword";
+            };
+            readonly sessionTitle: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly title: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly content: {
+                readonly type: "text";
+                readonly analyzer: "standard";
+            };
+            readonly role: {
+                readonly type: "keyword";
+            };
+            readonly type: {
+                readonly type: "keyword";
+            };
+            readonly href: {
+                readonly type: "keyword";
+            };
+            readonly category: {
+                readonly type: "keyword";
+            };
+            readonly tenantId: {
+                readonly type: "keyword";
+            };
+            readonly userId: {
+                readonly type: "keyword";
+            };
+            readonly createdAt: {
+                readonly type: "date";
+            };
+            readonly embedding: {
+                readonly type: "knn_vector";
+                readonly dimension: 1024;
+                readonly method: {
+                    readonly name: "hnsw";
+                    readonly space_type: "cosinesimil";
+                    readonly engine: "faiss";
+                    readonly parameters: {
+                        readonly ef_construction: 128;
+                        readonly m: 16;
+                    };
+                };
+            };
+        };
+    };
+}];
+/**
+ * Unified search configuration
+ */
+export declare const UNIFIED_SEARCH_CONFIG: {
+    /** Minimum score threshold for semantic search results (0-1, cosine similarity) */
+    readonly MIN_SEMANTIC_SCORE: 0.65;
+    /** Ratio of max score used as threshold for filtering low-relevance results */
+    readonly SCORE_THRESHOLD_RATIO: 0.2;
+    /** Divisor for normalizing OpenSearch scores to 0-1 range */
+    readonly SCORE_NORMALIZATION_DIVISOR: 10;
+    /** Batch size for count queries when calculating total results */
+    readonly COUNT_QUERY_BATCH_SIZE: 1000;
+    /** Multiplier for k-NN vector search (k = limit * multiplier) - deprecated in favor of KNN_MULTIPLIER_CONFIG */
+    readonly KNN_MULTIPLIER: 3;
+    /**
+     * Threshold for using parallel search (number of indices).
+     * When searching more than this many indices with semantic search,
+     * use parallel search for better performance.
+     */
+    readonly PARALLEL_SEARCH_THRESHOLD: 2;
+};
+/**
+ * k-NN search parameters for different search modes
+ * ef_search controls the size of the dynamic candidate list during search
+ * Higher values = better recall but slower search
+ */
+export declare const KNN_SEARCH_PARAMS: {
+    /** ef_search for standard keyword + semantic hybrid search */
+    readonly STANDARD_EF_SEARCH: 100;
+    /** ef_search for semantic-only search (higher for better recall) */
+    readonly SEMANTIC_ONLY_EF_SEARCH: 150;
+    /** ef_search for hybrid search with keyword fallback (lower for better performance) */
+    readonly HYBRID_EF_SEARCH: 80;
+};
+/**
+ * Dynamic k-NN multiplier configuration for optimizing vector search performance
+ * k controls how many nearest neighbors to retrieve before filtering
+ */
+export declare const KNN_MULTIPLIER_CONFIG: {
+    /** Multiplier for semantic-only searches (need more candidates to ensure good results) */
+    readonly SEMANTIC_ONLY: 4;
+    /** Multiplier for hybrid searches (keyword search helps, need fewer vector candidates) */
+    readonly HYBRID: 2;
+    /** Minimum k value to ensure reasonable recall */
+    readonly MIN_K: 20;
+};
+/**
+ * Source fields to return for each result type
+ * Excludes embedding field to reduce response size (~4KB per document)
+ */
+export declare const SEARCH_SOURCE_FIELDS: {
+    readonly document: readonly ["id", "collapseId", "title", "content", "description", "tenantId", "type", "href", "bucket", "key", "parentId"];
+    readonly message: readonly ["id", "collapseId", "sessionId", "sessionTitle", "content", "role", "type", "userId", "tenantId"];
+    readonly user: readonly ["id", "collapseId", "name", "displayName", "email", "tenantId", "type"];
+    readonly group: readonly ["id", "collapseId", "name", "description", "tenantId", "type"];
+    readonly agent: readonly ["id", "collapseId", "name", "description", "systemPrompt", "tenantId", "type"];
+    readonly feedback: readonly ["id", "collapseId", "title", "description", "status", "tenantId", "type"];
+    readonly chat: readonly ["id", "collapseId", "title", "tenantId", "userId", "type"];
+    readonly all: readonly ["id", "collapseId", "title", "name", "displayName", "content", "description", "email", "tenantId", "userId", "type", "sessionId", "sessionTitle", "role"];
+};
+/**
+ * OpenSearch query configuration for multi-match search
+ */
+export declare const QUERY_CONFIG: {
+    /** Boost factor for high-priority fields (title, name, displayName) */
+    readonly HIGH_PRIORITY_BOOST: 3;
+    /** Boost factor for medium-priority fields (content, description, email, roles) */
+    readonly MEDIUM_PRIORITY_BOOST: 2;
+    /** Boost factor for low-priority fields (instructions) */
+    readonly LOW_PRIORITY_BOOST: 1;
+    /** Minimum prefix length before applying fuzzy matching */
+    readonly FUZZY_PREFIX_LENGTH: 2;
+    /** Minimum should match for boolean queries */
+    readonly MINIMUM_SHOULD_MATCH: 1;
+};
+/**
+ * Content extraction configuration
+ */
+export declare const CONTENT_EXTRACTION_CONFIG: {
+    /** Maximum file size for content extraction (10MB) */
+    readonly MAX_FILE_SIZE: number;
+    /** Maximum content length for single extraction (legacy, used when chunking disabled) */
+    readonly MAX_CONTENT_LENGTH: 15000;
+};
+/**
+ * Document chunking configuration for semantic search
+ */
+export declare const CHUNK_CONFIG: {
+    /** Target chunk size in characters (~400 tokens for good embedding quality) */
+    readonly CHUNK_SIZE: 1500;
+    /** Overlap between chunks to maintain context */
+    readonly CHUNK_OVERLAP: 200;
+    /** Maximum number of chunks per document to prevent excessive indexing */
+    readonly MAX_CHUNKS: 50;
+};
+/**
+ * Supported file extensions for content extraction
+ */
+export declare const SUPPORTED_CONTENT_EXTENSIONS: readonly [".pdf", ".docx", ".txt", ".csv", ".json", ".md", ".html", ".htm", ".xml", ".rtf"];
+/**
+ * Legacy file formats that are not supported
+ * Note: .doc (legacy Word binary format) requires word-extractor library
+ */
+export declare const UNSUPPORTED_LEGACY_EXTENSIONS: readonly [".doc"];
+/**
+ * Sync service configuration constants
+ */
+export declare const SYNC_CONFIG: {
+    /** Empty delimiter for recursive S3 file listing */
+    readonly RECURSIVE_DELIMITER: "";
+    /** Number of items to process before sending progress update for chats */
+    readonly CHAT_PROGRESS_INTERVAL: 10;
+    /** Number of items to process before sending progress update for messages */
+    readonly MESSAGE_PROGRESS_INTERVAL: 50;
+    /** Default error count for successful operations */
+    readonly NO_ERRORS: 0;
+    /** Maximum number of S3 keys to fetch per batch */
+    readonly S3_MAX_KEYS_PER_BATCH: 1000;
+    /** Cognito user list limit for group member pagination */
+    readonly COGNITO_USER_LIST_LIMIT: 60;
+    /** Batch size for bulk indexing operations (number of documents per bulk API call) */
+    readonly BULK_INDEX_BATCH_SIZE: 50;
+    /** Maximum concurrent embedding generation requests (to avoid overwhelming Bedrock) */
+    readonly PARALLEL_EMBEDDING_CONCURRENCY: 10;
+    /** Maximum retries for connection pool exhaustion recovery */
+    readonly CONNECTION_RECOVERY_MAX_RETRIES: 3;
+    /** Delay between connection recovery retries in milliseconds */
+    readonly CONNECTION_RECOVERY_DELAY_MS: 1000;
+    /** Maximum retries for credential expiration recovery */
+    readonly CREDENTIAL_REFRESH_MAX_RETRIES: 2;
+    /** Delay before retrying after credential refresh in milliseconds */
+    readonly CREDENTIAL_REFRESH_DELAY_MS: 500;
+    /** Buffer time before expiration to proactively refresh credentials (5 minutes) */
+    readonly CREDENTIAL_EXPIRY_BUFFER_MS: number;
+};
+/**
+ * Message preview configuration
+ */
+export declare const MESSAGE_PREVIEW_CONFIG: {
+    /** Maximum characters for message title preview */
+    readonly TITLE_PREVIEW_LENGTH: 100;
+    /** Suffix for truncated previews */
+    readonly TRUNCATION_SUFFIX: "...";
+};
+/**
+ * Advanced chunking configuration for sentence-aware splitting
+ */
+export declare const CHUNK_SPLITTING_CONFIG: {
+    /** Characters before target chunk size to start searching for sentence break */
+    readonly SENTENCE_SEARCH_BEFORE: 200;
+    /** Characters after target chunk size to continue searching for sentence break */
+    readonly SENTENCE_SEARCH_AFTER: 100;
+    /** Minimum ratio of chunk size before accepting sentence break (0.5 = 50%) */
+    readonly MIN_CHUNK_SIZE_RATIO: 0.5;
+    /** Maximum recursion depth for JSON string extraction */
+    readonly MAX_JSON_RECURSION_DEPTH: 10;
+};
+/**
+ * String parsing and utility constants
+ */
+export declare const STRING_PARSING_CONFIG: {
+    /** Return value from indexOf/lastIndexOf when not found */
+    readonly NOT_FOUND_INDEX: -1;
+    /** Empty string constant for fallback values */
+    readonly EMPTY_STRING: "";
+};
+/**
+ * Configuration for search result content previews
+ */
+export declare const RESULT_PREVIEW_CONFIG: {
+    /** Character limit for document content preview */
+    readonly DOCUMENT_PREVIEW_LENGTH: 200;
+    /** Character limit for message content preview */
+    readonly MESSAGE_PREVIEW_LENGTH: 200;
+    /** Character limit for metadata content snippet */
+    readonly METADATA_SNIPPET_LENGTH: 300;
+};
+/**
+ * Mark tag for highlighting
+ */
+export declare const HIGHLIGHT_MARK_CLASS: "search-highlight";
+/**
+ * Highlight HTML configuration
+ */
+export declare const HIGHLIGHT_CONFIG: {
+    /** HTML tag to wrap highlighted text (uses class for client-side styling) */
+    readonly PRE_TAG: "<mark class=\"search-highlight\">";
+    /** Closing HTML tag for highlights */
+    readonly POST_TAG: "</mark>";
+    /** Number of fragments for single-line fields */
+    readonly SINGLE_FRAGMENT_COUNT: 1;
+    /** Number of fragments for multi-line content fields */
+    readonly CONTENT_FRAGMENT_COUNT: 3;
+    /** Number of fragments for description fields */
+    readonly DESCRIPTION_FRAGMENT_COUNT: 2;
+    /** Fragment size in characters for content/description fields */
+    readonly FRAGMENT_SIZE: 150;
+};
+/**
+ * Common validation limits used in schemas
+ */
+export declare const VALIDATION_LIMITS: {
+    /** Minimum string length for required fields */
+    readonly MIN_STRING_LENGTH: 1;
+    /** Minimum numeric value (non-negative) */
+    readonly MIN_NUMERIC_VALUE: 0;
+};
+/**
+ * Boolean string values for query parameter parsing
+ */
+export declare const BOOLEAN_STRING_VALUES: readonly ["true", "false", "1", "0"];
+/**
+ * Boolean string true values
+ */
+export declare const BOOLEAN_TRUE_STRING: "true";
+export declare const BOOLEAN_ONE_STRING: "1";
+/**
+ * Index creation status values for sync/creation responses
+ */
+export declare const INDEX_STATUS: {
+    readonly ALREADY_EXISTS: "already_exists";
+    readonly CREATED: "created";
+    readonly ERROR: "error";
+};
+/**
+ * SSE (Server-Sent Events) response headers
+ */
+export declare const SSE_HEADERS: {
+    readonly CONTENT_TYPE: "text/event-stream";
+    readonly CACHE_CONTROL: "no-cache";
+    readonly CONNECTION: "keep-alive";
+};
+/**
+ * SSE event format strings
+ */
+export declare const SSE_EVENT_FORMAT: {
+    /** Event data prefix */
+    readonly DATA_PREFIX: "data: ";
+    /** Event terminator (double newline) */
+    readonly EVENT_TERMINATOR: "\n\n";
+    /** Keepalive comment (SSE comment format, ignored by clients) */
+    readonly KEEPALIVE: ":keepalive\n\n";
+};
+/**
+ * SSE keepalive configuration
+ */
+export declare const SSE_KEEPALIVE_CONFIG: {
+    /** Interval between keepalive messages in milliseconds (30 seconds) */
+    readonly INTERVAL_MS: 30000;
+};
+/**
+ * Sync progress event types
+ */
+export declare const SYNC_PROGRESS_TYPES: {
+    readonly START: "start";
+    readonly PROGRESS: "progress";
+    readonly COMPLETE: "complete";
+    readonly ERROR: "error";
+    readonly DONE: "done";
+};
+/**
+ * Search type filter value for "all" types
+ */
+export declare const SEARCH_TYPE_ALL: "all";
+/**
+ * Cache configuration for search API responses.
+ * Short TTL to reduce redundant requests while keeping results fresh.
+ */
+export declare const SEARCH_CACHE_CONFIG: {
+    /** Cache TTL in seconds (60 seconds) */
+    readonly TTL_SECONDS: 60;
+    /** Cache-Control header value for search responses */
+    readonly CACHE_CONTROL: "private, max-age=60";
+};
+/**
+ * Search response cache configuration for server-side LRU cache.
+ * Optimizes performance by caching recent search results with tenant/user isolation.
+ */
+export declare const SEARCH_RESPONSE_CACHE_CONFIG: {
+    /** Maximum number of cached entries (LRU eviction when exceeded) */
+    readonly MAX_SIZE: 1000;
+    /** Cache entry TTL in milliseconds (30 seconds) */
+    readonly TTL_MS: 30000;
+    /** Interval for cleanup of expired entries in milliseconds (10 seconds) */
+    readonly CLEANUP_INTERVAL_MS: 10000;
+};
+/**
+ * Index metadata keys for version tracking (stored in mappings._meta)
+ */
+export declare const INDEX_METADATA_KEYS: {
+    /** Key for storing schema version in mappings._meta */
+    readonly SCHEMA_VERSION: "schema_version";
+    /** Key for storing creation timestamp in mappings._meta */
+    readonly CREATED_AT: "created_at";
+};
+/**
+ * Migration status values
+ */
+export declare const MIGRATION_STATUS: {
+    /** Index is up-to-date */
+    readonly UP_TO_DATE: "up_to_date";
+    /** Index needs migration (version mismatch) */
+    readonly NEEDS_MIGRATION: "needs_migration";
+    /** Index does not exist */
+    readonly NOT_EXISTS: "not_exists";
+    /** Migration in progress */
+    readonly IN_PROGRESS: "in_progress";
+    /** Migration completed successfully */
+    readonly COMPLETED: "completed";
+    /** Migration failed */
+    readonly FAILED: "failed";
+    /** Version unknown (legacy index without version) */
+    readonly UNKNOWN_VERSION: "unknown_version";
+};
+/**
+ * Migration configuration
+ */
+export declare const MIGRATION_CONFIG: {
+    /** Batch size for reindex operations */
+    readonly REINDEX_BATCH_SIZE: 1000;
+    /** Timeout for reindex operations in milliseconds (30 minutes) */
+    readonly REINDEX_TIMEOUT_MS: number;
+    /** Delay between reindex status checks in milliseconds */
+    readonly REINDEX_POLL_INTERVAL_MS: 2000;
+    /** Suffix for temporary migration index */
+    readonly TEMP_INDEX_SUFFIX: "_migration_temp";
+    /** Version to assign to legacy indices without version metadata */
+    readonly LEGACY_VERSION: "0.0";
+};
+/**
+ * Migration error messages
+ */
+export declare const MIGRATION_ERROR_MESSAGES: {
+    readonly INDEX_NOT_FOUND: "Index not found";
+    readonly MIGRATION_IN_PROGRESS: "Migration already in progress for this index";
+    readonly REINDEX_FAILED: "Reindex operation failed";
+    readonly REINDEX_TIMEOUT: "Reindex operation timed out";
+    readonly VERSION_PARSE_ERROR: "Failed to parse version string";
+    readonly ALIAS_UPDATE_FAILED: "Failed to update index alias";
+    readonly INDEX_CREATION_FAILED: "Failed to create index";
+    readonly MIGRATION_FAILED: "Index migration failed";
+};
+/**
+ * Health status to Tailwind color class mapping
+ */
+export declare const HEALTH_COLOR_MAP: {
+    readonly green: "bg-green-500";
+    readonly yellow: "bg-yellow-500";
+    readonly red: "bg-red-500";
+    readonly unknown: "bg-gray-500";
+};
+/**
+ * Search performance metrics configuration for monitoring and optimization.
+ * These settings control when and how metrics are logged for search operations.
+ */
+export declare const SEARCH_METRICS_CONFIG: {
+    /** Interval for periodic metrics logging in milliseconds (1 minute) */
+    readonly LOG_INTERVAL_MS: 60000;
+    /** Warning threshold for search latency in milliseconds */
+    readonly LATENCY_WARN_THRESHOLD_MS: 500;
+    /** Memory estimation bytes per cache entry (rough average) */
+    readonly EMBEDDING_CACHE_ENTRY_SIZE_BYTES: 4096;
+    /** Memory estimation bytes per response cache entry (rough average) */
+    readonly RESPONSE_CACHE_ENTRY_SIZE_BYTES: 2048;
+};
+/**
+ * File size units and thresholds
+ */
+export declare const FILE_SIZE_UNITS: {
+    readonly BYTES_PER_KB: 1024;
+    readonly BYTES_PER_MB: number;
+    readonly BYTES_PER_GB: number;
+    readonly DECIMAL_PLACES: 1;
+};
+/**
+ * Content preview and truncation lengths
+ */
+export declare const CONTENT_PREVIEW_LIMITS: {
+    /** Maximum characters for content snippet in search results */
+    readonly SNIPPET_LENGTH: 150;
+    /** Maximum characters for message description preview */
+    readonly MESSAGE_DESCRIPTION_LENGTH: 150;
+    /** Number of content highlights to show in document results */
+    readonly MAX_CONTENT_HIGHLIGHTS: 2;
+};
+/**
+ * Keyboard shortcuts
+ */
+export declare const SEARCH_KEYBOARD_SHORTCUTS: {
+    /** Ctrl + F to open search (when not in editable element) */
+    readonly FIND_KEY: "f";
+};
+/**
+ * Available search tabs configuration with LucideIcon components
+ */
+export declare const COMPONENT_SEARCH_TABS: ComponentSearchTab[];
+/**
+ * Type icons for search results
+ */
+export declare const TYPE_ICONS: Record<(typeof SEARCH_RESULT_TYPES)[number], LucideIcon>;
+/**
+ * Type colors for category badges in search results
+ */
+export declare const TYPE_COLORS: Record<(typeof SEARCH_RESULT_TYPES)[number], string>;
+/**
+ * Search suggestions for empty state
+ */
+export declare const SEARCH_SUGGESTIONS: readonly ["Try searching for a document name", "Search for a colleague by name", "Find an AI agent to help you", "Look up recent feedback items"];
+/**
+ * File type icon mapping
+ */
+export declare const FILE_EXTENSION_ICONS: Record<string, LucideIcon>;
+/**
+ * Default file icon (fallback)
+ */
+export declare const DEFAULT_FILE_ICON: LucideIcon;
+/**
+ * Message role display names
+ */
+export declare const MESSAGE_ROLE_LABELS: {
+    readonly user: "You";
+    readonly assistant: "Assistant";
+    readonly system: "System";
+};
+/**
+ * Message role colors
+ */
+export declare const MESSAGE_ROLE_COLORS: {
+    readonly user: "text-blue-500/70";
+    readonly assistant: "text-green-500/70";
+    readonly system: "text-muted-foreground/60";
+};
+/**
+ * Index name prefix for Captify search indices
+ */
+export declare const CAPTIFY_INDEX_PREFIX: "captify-search-";
+//# sourceMappingURL=search.constants.d.ts.map