captify 0.1.18 → 0.1.19

package/dist/search/search.interfaces.d.ts

@@ -0,0 +1,1085 @@
+/**
+ * Search Module Interfaces
+ *
+ * TypeScript interfaces for the global unified search feature.
+ * Types derived from Zod schemas are re-exported from search.schemas.ts.
+ */
+import type { Client as OpenSearchClient } from "@opensearch-project/opensearch";
+import type { LucideIcon } from "lucide-react";
+import type { Logger } from "../shared/services/logger";
+import type { S3Service } from "../shared/services/s3";
+import type { UserAwsCredentials } from "../shared/services/services.interfaces";
+import type { SEARCH_RESULT_TYPES, SYNCABLE_INDICES } from "./search.constants";
+import type { EmbeddingService } from "./services/embedding.service";
+import type { OpenSearchService } from "./services/opensearch.service";
+import type { BaseSearchResponse, SearchResult } from "./search.schemas";
+/**
+ * Searchable result type enumeration
+ */
+export type SearchResultType = (typeof SEARCH_RESULT_TYPES)[number];
+/**
+ * Search query parameters from the API request
+ */
+export interface SearchQuery {
+    /** Search query string (min 2 characters) */
+    query: string;
+    /** Filter by result type (optional, defaults to 'all') */
+    type?: SearchResultType | "all";
+    /** Maximum results to return (default: 10, max: 50) */
+    limit?: number;
+    /** Pagination offset (deprecated: prefer searchAfter for deep pagination) */
+    offset?: number;
+    /**
+     * Cursor for search_after pagination (50-70% faster for deep pages).
+     * Use the nextCursor from the previous response's pagination object.
+     * When provided, offset is ignored.
+     */
+    searchAfter?: (string | number)[];
+    /** Tenant context for multi-tenancy */
+    tenantId: string;
+    /** User ID for permission filtering */
+    userId: string;
+    /** User AWS credentials for governance compliance */
+    userCredentials?: UserAwsCredentials;
+    /** Enable semantic/hybrid search using vector embeddings */
+    semantic?: boolean;
+    /** Use semantic-only search (no keyword matching, pure vector similarity) */
+    semanticOnly?: boolean;
+    /** Minimum score threshold */
+    minScore?: number;
+    /** Visible result types (only these types will be searched/shown) */
+    visibleTypes?: SearchResultType[];
+    /** AbortSignal for cancelling in-progress search operations */
+    signal?: AbortSignal;
+}
+/**
+ * Degraded search mode information
+ * Indicates when search quality is reduced due to service issues
+ */
+export interface DegradedSearchInfo {
+    /** Reason for degraded mode */
+    reason: string;
+    /** Original requested mode that couldn't be fulfilled */
+    requestedMode: "semantic" | "hybrid";
+    /** Actual mode used */
+    actualMode: "keyword-only";
+}
+/**
+ * API response containing search results
+ * Extends BaseSearchResponse with optional degraded mode info
+ */
+export interface SearchResponse extends BaseSearchResponse {
+    /** Present when search fell back to a degraded mode (e.g., semantic unavailable) */
+    degraded?: DegradedSearchInfo;
+    /** Maximum score from results */
+    maxScore?: number;
+    /** Indicates if response was served from cache */
+    fromCache?: boolean;
+}
+/**
+ * Recent search entry stored in localStorage
+ */
+export interface RecentSearch {
+    /** Result ID */
+    id: string;
+    /** Result title */
+    title: string;
+    /** Result type */
+    type: SearchResultType;
+    /** Navigation URL */
+    href: string;
+    /** When this result was selected (timestamp) */
+    selectedAt: number;
+}
+/**
+ * OpenSearch hit from search response
+ */
+export interface OpenSearchHit<T = Record<string, unknown>> {
+    _index: string;
+    _id: string;
+    _score: number | null;
+    _source: T;
+    highlight?: Record<string, string[]>;
+    /** Sort values for search_after cursor-based pagination */
+    sort?: (string | number)[];
+}
+/**
+ * OpenSearch search response structure
+ */
+export interface OpenSearchResponse<T = Record<string, unknown>> {
+    took: number;
+    timed_out: boolean;
+    _shards: {
+        total: number;
+        successful: number;
+        skipped: number;
+        failed: number;
+    };
+    hits: {
+        total: {
+            value: number;
+            relation: "eq" | "gte";
+        };
+        max_score: number | null;
+        hits: OpenSearchHit<T>[];
+    };
+    aggregations?: Record<string, unknown>;
+}
+/**
+ * Base fields common to all indexed sources
+ */
+export interface BaseIndexSource {
+    id: string;
+    tenantId: string;
+    /** Navigation URL for this result */
+    href?: string;
+    /** Result type identifier */
+    type?: string;
+    /** Display category label */
+    category?: string;
+    /** Collapse ID for deduplication */
+    collapseId?: string;
+}
+/**
+ * Document index source fields
+ */
+export interface DocumentSource extends BaseIndexSource {
+    title: string;
+    originalName?: string;
+    content?: string;
+    /** S3 bucket name */
+    bucket?: string;
+    key?: string;
+    size?: number;
+    lastModified?: string;
+    documentId?: string;
+    /** Parent document ID (for chunked documents) */
+    parentId?: string;
+    /** Chunk index (0-based, for chunked documents) */
+    chunkIndex?: number;
+    /** Total number of chunks in the document */
+    totalChunks?: number;
+}
+/**
+ * User index source fields
+ */
+export interface UserSource extends BaseIndexSource {
+    username?: string;
+    email?: string;
+    displayName?: string;
+    department?: string;
+    jobTitle?: string;
+    organization?: string;
+    enabled?: boolean;
+    status?: string;
+    roles?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Group index source fields
+ */
+export interface GroupSource extends BaseIndexSource {
+    name: string;
+    description?: string;
+    memberCount?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Agent index source fields
+ */
+export interface AgentSource extends BaseIndexSource {
+    name: string;
+    description?: string;
+    instructions?: string;
+    status?: string;
+    modelId?: string;
+    providerId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Feedback index source fields
+ */
+export interface FeedbackSource extends BaseIndexSource {
+    title: string;
+    description?: string;
+    priority?: string;
+    status?: string;
+    createdBy?: string;
+    createdByName?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * Chat index source fields
+ */
+export interface ChatSource extends BaseIndexSource {
+    userId: string;
+    title: string;
+    messageCount?: number;
+    isArchived?: boolean;
+    lastUpdated?: string;
+    createdAt?: string;
+}
+/**
+ * Message index source fields
+ */
+export interface MessageSource extends BaseIndexSource {
+    /** Required for messages - same as sessionId for deduplication */
+    collapseId: string;
+    userId: string;
+    sessionId: string;
+    sessionTitle?: string;
+    role: "user" | "assistant" | "system";
+    content: string;
+    createdAt?: string;
+}
+/**
+ * Union type of all source types
+ */
+export type IndexSource = DocumentSource | UserSource | GroupSource | AgentSource | FeedbackSource | ChatSource | MessageSource;
+/**
+ * Options for useSearch hook
+ */
+export interface UseSearchOptions {
+    /** Debounce delay in milliseconds */
+    debounceMs?: number;
+    /** Initial type filter */
+    initialType?: SearchResultType | "all";
+    /** Whether to auto-focus on mount */
+    autoFocus?: boolean;
+    /** Enable semantic/hybrid search (keyword + vector boost) */
+    semantic?: boolean;
+    /** Enable semantic-only search (pure vector, best for natural language) */
+    semanticOnly?: boolean;
+    /** Visible result types (only these types will be searched/shown) */
+    visibleTypes?: SearchResultType[];
+}
+/**
+ * Return type for useSearch hook
+ */
+export interface UseSearchReturn {
+    /** Current query string */
+    query: string;
+    /** Set query string */
+    setQuery: (query: string) => void;
+    /** Search results */
+    results: SearchResult[];
+    /** Loading state for initial fetch */
+    isLoading: boolean;
+    /** Loading state for fetching more pages */
+    isFetchingNextPage: boolean;
+    /** Error message */
+    error: string | null;
+    /** Current type filter */
+    type: SearchResultType | "all";
+    /** Set type filter */
+    setType: (type: SearchResultType | "all") => void;
+    /** Total results count */
+    total: number;
+    /** Whether more results are available */
+    hasMore: boolean;
+    /** Fetch next page of results */
+    fetchNextPage: () => void;
+    /** Retry search */
+    retry: () => void;
+    /** Clear search */
+    clear: () => void;
+}
+/**
+ * Props for GlobalSearchBar component
+ */
+export interface GlobalSearchBarProps {
+    /** Placeholder text */
+    placeholder?: string;
+    /** Show keyboard shortcut hint */
+    showShortcutHint?: boolean;
+    /** Callback when a result is selected */
+    onResultSelect?: (result: SearchResult) => void;
+    /** Additional class names */
+    className?: string;
+}
+/**
+ * Search tab configuration for filtering UI
+ */
+export interface SearchTab {
+    /** Tab identifier */
+    id: SearchResultType | "all";
+    /** Display label */
+    label: string;
+    /** Lucide icon component name */
+    icon: string;
+    /** Whether tab is visible by default */
+    visible: boolean;
+}
+/** Lock operation types */
+export type LockOperation = "sync" | "delete" | "reindex";
+/** Lock change event types */
+export type LockEventType = "acquired" | "released" | "progress";
+/** Lock information */
+export interface IndexLock {
+    /** Index being locked */
+    indexName: string;
+    /** Type of operation */
+    operation: LockOperation;
+    /** User who acquired the lock */
+    userId: string;
+    /** Display name of the user */
+    userName: string;
+    /** User's email */
+    userEmail?: string;
+    /** Tenant ID */
+    tenantId: string;
+    /** When the lock was acquired */
+    startedAt: string;
+    /** Lock expiration time (for stale lock cleanup) */
+    expiresAt: string;
+    /** Current progress information */
+    progress?: {
+        current: number;
+        total: number;
+        message: string;
+        phase?: string;
+    };
+    /** Last progress update time */
+    updatedAt: string;
+}
+/** Lock change event */
+export interface LockEvent {
+    type: LockEventType;
+    lock: IndexLock | null;
+    indexName: string;
+}
+/** Result of attempting to acquire a lock */
+export interface AcquireLockResult {
+    success: boolean;
+    /** If failed, the existing lock info */
+    existingLock?: IndexLock;
+    /** Error message if applicable */
+    error?: string;
+}
+/**
+ * OpenSearch index information from cluster
+ */
+export interface IndexInfo {
+    /** Index name */
+    index: string;
+    /** Index health status */
+    health: string;
+    /** Index status */
+    status: string;
+    /** Number of documents */
+    docsCount: string;
+    /** Lock information if the index is locked */
+    lock?: {
+        operation: string;
+        userId: string;
+        userName: string;
+        isOwnLock: boolean;
+        progress?: {
+            current: number;
+            total: number;
+            message: string;
+        };
+        startedAt: string;
+    } | null;
+}
+/**
+ * Result of creating an index
+ */
+export interface CreateResult {
+    /** Index name */
+    name: string;
+    /** Creation status */
+    status: string;
+    /** Schema version if created */
+    version?: string;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Represents an item that was recently synced (for UI display)
+ */
+export interface SyncedItem {
+    /** Item identifier */
+    id: string;
+    /** Display name for the item */
+    name: string;
+    /** Status: synced successfully or failed */
+    status: "synced" | "failed";
+    /** Timestamp when synced */
+    timestamp: number;
+}
+/**
+ * Active sync operation progress display
+ */
+export interface ActiveSync {
+    /** Index being synced */
+    index: string;
+    /** Current item number */
+    current: number;
+    /** Total items to sync */
+    total: number;
+    /** Progress message */
+    message: string;
+    /** Recently synced items (for scrollable list display) */
+    recentItems: SyncedItem[];
+}
+/**
+ * Options for useSearchIndices hook
+ */
+export interface UseSearchIndicesOptions {
+    enabled?: boolean;
+}
+/**
+ * Return type for useSearchIndices hook
+ */
+export interface UseSearchIndicesReturn {
+    indices: IndexInfo[];
+    definitions: string[];
+    captifyIndices: IndexInfo[];
+    otherIndices: IndexInfo[];
+    missingIndices: string[];
+    loading: boolean;
+    creating: boolean;
+    syncing: boolean;
+    deleting: string | null;
+    syncingIndex: string | null;
+    results: CreateResult[] | null;
+    syncResults: SyncResult[] | null;
+    activeSync: ActiveSync | null;
+    error: string | null;
+    isSyncInProgress: boolean;
+    fetchIndices: () => Promise<void>;
+    createIndices: (indexName?: string) => Promise<void>;
+    deleteIndex: (indexName: string) => Promise<void>;
+    syncData: (indexName?: string) => Promise<void>;
+}
+/**
+ * Search query parameters for the client
+ */
+export interface SearchClientParams {
+    /** Search query string */
+    query: string;
+    /** Filter by result type */
+    type?: SearchResultType | "all";
+    /** Results per page */
+    limit?: number;
+    /** Pagination offset (ignored when searchAfter is provided) */
+    offset?: number;
+    /**
+     * Cursor for search_after pagination (50-70% faster for deep pages).
+     * Use the nextCursor from the previous response's pagination object.
+     * When provided, offset is ignored.
+     */
+    searchAfter?: (string | number)[];
+    /** Enable semantic/hybrid search (keyword + vector) */
+    semantic?: boolean;
+    /** Enable semantic-only search (pure vector, no keywords) */
+    semanticOnly?: boolean;
+    /** Minimum score threshold for filtering low-relevance results */
+    minScore?: number;
+    /** Visible result types (only these types will be searched/shown) */
+    visibleTypes?: SearchResultType[];
+    /** AbortController signal for cancellation */
+    signal?: AbortSignal;
+}
+/**
+ * Result of syncing a single index
+ */
+export interface SyncResult {
+    /** Index name */
+    index: string;
+    /** Number of successfully indexed items */
+    indexed: number;
+    /** Number of errors encountered */
+    errors: number;
+    /** Overall status of the sync */
+    status: "success" | "partial" | "error";
+    /** Error messages if any */
+    errorMessages?: string[];
+}
+/**
+ * Progress update when sync starts for an index
+ */
+export interface SyncStartProgress {
+    type: "start";
+    /** Index being synced */
+    index: string;
+    /** Total items to process */
+    total: number;
+    /** Human-readable message */
+    message: string;
+}
+/**
+ * Progress update during sync operation
+ */
+export interface SyncProgressUpdate {
+    type: "progress";
+    /** Index being synced */
+    index: string;
+    /** Current item number */
+    current: number;
+    /** Total items to process */
+    total: number;
+    /** Human-readable message */
+    message: string;
+    /** Recently processed items (for live display) */
+    items?: Array<{
+        id: string;
+        name: string;
+        status: "synced" | "failed";
+    }>;
+}
+/**
+ * Progress update when an index sync completes
+ */
+export interface SyncCompleteProgress {
+    type: "complete";
+    /** Index that completed */
+    index: string;
+    /** Sync result for this index */
+    result: SyncResult;
+    /** Human-readable message */
+    message: string;
+}
+/**
+ * Progress update when an error occurs
+ */
+export interface SyncErrorProgress {
+    type: "error";
+    /** Index that errored (optional for general errors) */
+    index?: string;
+    /** Error message */
+    message: string;
+}
+/**
+ * Progress update when all indices are done
+ */
+export interface SyncDoneProgress {
+    type: "done";
+    /** Final results for all indices */
+    results: SyncResult[];
+    /** Human-readable message */
+    message?: string;
+}
+/**
+ * Discriminated union of all sync progress event types.
+ * Each type has its own required fields, preventing invalid states.
+ */
+export type SyncProgress = SyncStartProgress | SyncProgressUpdate | SyncCompleteProgress | SyncErrorProgress | SyncDoneProgress;
+/**
+ * Callback for receiving progress updates
+ */
+export type ProgressCallback = (progress: SyncProgress) => void;
+/**
+ * Callback to refresh AWS credentials during long-running operations.
+ * Returns fresh credentials when the current ones expire.
+ */
+export type RefreshCredentialsCallback = () => Promise<UserAwsCredentials>;
+/**
+ * Parameters for sync operation
+ */
+export interface SyncParams {
+    /** Tenant ID */
+    tenantId: string;
+    /** User ID performing the sync */
+    userId: string;
+    /** User AWS credentials */
+    userCredentials: UserAwsCredentials;
+    /** Optional specific indices to sync (defaults to all) */
+    indices?: SyncableIndex[];
+    /** Progress callback */
+    onProgress: ProgressCallback;
+    /** Abort signal for cancellation (e.g., when client disconnects) */
+    signal?: AbortSignal;
+    /**
+     * Callback to refresh credentials during long-running operations.
+     * If provided, the sync service will automatically refresh credentials
+     * when they expire (ExpiredTokenException).
+     */
+    refreshCredentials?: RefreshCredentialsCallback;
+}
+/**
+ * Valid indices that can be synced
+ */
+export type SyncableIndex = (typeof SYNCABLE_INDICES)[number];
+/**
+ * OpenSearch service configuration
+ */
+export interface OpenSearchConfig {
+    /** OpenSearch endpoint URL */
+    endpoint: string;
+    /** AWS region for the OpenSearch domain */
+    region: string;
+    /** AWS credentials for SigV4 authentication (service account) */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** Request timeout in milliseconds */
+    requestTimeout?: number;
+}
+/**
+ * OpenSearch service dependencies for dependency injection
+ */
+export interface OpenSearchServiceDeps {
+    client?: OpenSearchClient;
+    logger?: Logger;
+    config: OpenSearchConfig;
+}
+/**
+ * Search options for OpenSearch queries
+ */
+export interface SearchOptions {
+    /** Index or indices to search (comma-separated or array) */
+    indices: string | string[];
+    /** OpenSearch query DSL */
+    query: Record<string, unknown>;
+    /** Fields to return */
+    _source?: string[] | boolean;
+    /** Sort configuration */
+    sort?: Record<string, unknown>[];
+    /** Number of results to return */
+    size?: number;
+    /** Offset for pagination (ignored when searchAfter is provided) */
+    from?: number;
+    /**
+     * Cursor for search_after pagination (50-70% faster for deep pages).
+     * When provided, 'from' is ignored.
+     */
+    searchAfter?: (string | number)[];
+    /** Highlight configuration */
+    highlight?: {
+        fields: Record<string, Record<string, unknown>>;
+        pre_tags?: string[];
+        post_tags?: string[];
+    };
+    /** Aggregations configuration */
+    aggs?: Record<string, unknown>;
+    /** Collapse configuration for deduplication */
+    collapse?: {
+        field: string;
+        inner_hits?: {
+            name: string;
+            size: number;
+        };
+    };
+    /** Minimum score threshold for filtering low-relevance results */
+    minScore?: number;
+    /** User credentials for governance compliance */
+    userCredentials?: UserAwsCredentials;
+}
+/**
+ * OpenSearch cluster health check result
+ */
+export interface HealthCheckResult {
+    status: "green" | "yellow" | "red" | "unavailable";
+    clusterName?: string;
+    numberOfNodes?: number;
+    activePrimaryShards?: number;
+    error?: string;
+}
+/**
+ * Embedding service dependencies for dependency injection
+ */
+export interface EmbeddingServiceDeps {
+    logger?: Logger;
+    region?: string;
+}
+/**
+ * Response from Amazon Titan Embedding model
+ */
+export interface TitanEmbeddingResponse {
+    embedding: number[];
+    inputTextTokenCount: number;
+}
+/**
+ * Cache entry for embedding results
+ */
+export interface EmbeddingCacheEntry {
+    /** The embedding vector */
+    embedding: number[];
+    /** Timestamp when entry was cached */
+    cachedAt: number;
+}
+/**
+ * Unified search service dependencies for dependency injection
+ */
+export interface UnifiedSearchServiceDeps {
+    opensearchService?: OpenSearchService;
+    embeddingService?: EmbeddingService;
+    logger?: Logger;
+}
+/**
+ * k-NN search parameters for a specific search mode
+ */
+export interface KnnSearchConfig {
+    /** Number of nearest neighbors to retrieve */
+    k: number;
+    /** ef_search parameter for HNSW algorithm - controls search quality vs speed tradeoff */
+    efSearch: number;
+}
+/**
+ * Sync service dependencies for dependency injection
+ */
+export interface SyncServiceDeps {
+    logger?: Logger;
+}
+/**
+ * Context for sync operations (passed to sync methods)
+ */
+export interface SyncContext {
+    client: OpenSearchClient;
+    tenantId: string;
+    userCredentials: UserAwsCredentials;
+    embeddingService: EmbeddingService;
+    contentExtractionService: import("./services/content-extraction.service").ContentExtractionService;
+    /** OpenSearch service for bulk operations */
+    opensearchService: import("./services/opensearch.service").OpenSearchService;
+    onProgress: ProgressCallback;
+    /** Abort signal for cancellation (e.g., when client disconnects) */
+    signal?: AbortSignal;
+    /**
+     * Callback to refresh credentials during long-running operations.
+     * If provided, will be called when ExpiredTokenException is encountered.
+     */
+    refreshCredentials?: RefreshCredentialsCallback;
+}
+/**
+ * File information from S3 listing
+ */
+export interface FileInfo {
+    key: string;
+    size?: number;
+    lastModified?: Date;
+    originalName?: string;
+}
+/**
+ * Content extraction service dependencies for dependency injection
+ */
+export interface ContentExtractionServiceDeps {
+    logger?: Logger;
+    s3Service?: S3Service;
+}
+/**
+ * Result of extracting content from a single document (non-chunked)
+ */
+export interface ContentExtractionResult {
+    /** Extracted text content */
+    content: string;
+    /** Timestamp of extraction */
+    extractedAt: string;
+    /** File type extension (e.g., ".pdf") */
+    fileType: string;
+    /** Whether content was truncated due to length limits */
+    truncated: boolean;
+}
+/**
+ * A single chunk of extracted document content
+ */
+export interface ContentChunk {
+    /** Chunk index (0-based) */
+    index: number;
+    /** The text content of this chunk */
+    content: string;
+    /** Character offset in the original document */
+    startOffset: number;
+    /** Character offset end in the original document */
+    endOffset: number;
+}
+/**
+ * Result of chunked content extraction
+ */
+export interface ChunkedExtractionResult {
+    /** All content chunks */
+    chunks: ContentChunk[];
+    /** Total character count of original content */
+    totalLength: number;
+    /** Extraction timestamp */
+    extractedAt: string;
+    /** File type extension */
+    fileType: string;
+    /** Whether content was truncated due to max chunks limit */
+    truncated: boolean;
+}
+/**
+ * Cache entry with TTL tracking for search response cache
+ */
+export interface SearchResponseCacheEntry {
+    /** Cached search response */
+    response: SearchResponse;
+    /** Timestamp when entry was created */
+    timestamp: number;
+    /** Last access timestamp for LRU tracking */
+    lastAccessed: number;
+}
+/**
+ * Cache statistics for search response cache monitoring
+ */
+export interface SearchResponseCacheStats {
+    /** Total number of cached entries */
+    size: number;
+    /** Number of cache hits */
+    hits: number;
+    /** Number of cache misses */
+    misses: number;
+    /** Hit rate percentage (0-100) */
+    hitRate: number;
+    /** Number of expired entries cleaned up */
+    cleanupCount: number;
+}
+/**
+ * OpenSearch index definition with versioning support for schema migrations.
+ * Version numbers enable tracking schema changes and supporting zero-downtime migrations.
+ */
+export interface IndexDefinition {
+    /** Index name (e.g., "captify-search-documents") */
+    name: string;
+    /** Schema version number for migration tracking (semver-style: major.minor) */
+    version: string;
+    /** Index settings (e.g., k-NN enabled) */
+    settings: Record<string, unknown>;
+    /** OpenSearch field mappings */
+    mappings: {
+        properties: Record<string, unknown>;
+    };
+}
+/**
+ * Migration status for a single index
+ */
+export interface IndexMigrationStatus {
+    /** Index name */
+    indexName: string;
+    /** Current deployed version (null if index doesn't exist) */
+    currentVersion: string | null;
+    /** Target version from INDEX_DEFINITIONS */
+    targetVersion: string;
+    /** Migration status */
+    status: "up_to_date" | "needs_migration" | "not_exists" | "unknown_version";
+    /** Whether a major version change is required (breaking change) */
+    isMajorChange: boolean;
+    /** Human-readable status message */
+    message: string;
+}
+/**
+ * Migration plan for all indices
+ */
+export interface MigrationPlan {
+    /** Overall status */
+    status: "all_up_to_date" | "migrations_needed" | "indices_missing";
+    /** Individual index statuses */
+    indices: IndexMigrationStatus[];
+    /** Number of indices needing migration */
+    migrationCount: number;
+    /** Number of indices that don't exist */
+    missingCount: number;
+    /** Timestamp of plan generation */
+    generatedAt: string;
+}
+/**
+ * Result of migrating a single index
+ */
+export interface IndexMigrationResult {
+    /** Index name */
+    indexName: string;
+    /** Migration status */
+    status: "completed" | "failed" | "skipped";
+    /** Previous version */
+    fromVersion: string | null;
+    /** New version */
+    toVersion: string;
+    /** Number of documents migrated */
+    documentsCount?: number;
+    /** Time taken in milliseconds */
+    durationMs?: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Result of migrating all indices
+ */
+export interface MigrationResult {
+    /** Overall status */
+    status: "completed" | "partial" | "failed";
+    /** Individual index results */
+    results: IndexMigrationResult[];
+    /** Total time taken in milliseconds */
+    totalDurationMs: number;
+    /** Number of successful migrations */
+    successCount: number;
+    /** Number of failed migrations */
+    failedCount: number;
+    /** Number of skipped migrations (already up-to-date) */
+    skippedCount: number;
+    /** Timestamp of migration completion */
+    completedAt: string;
+}
+/**
+ * Migration service dependencies
+ */
+export interface MigrationServiceDeps {
+    logger?: import("../shared/services/logger").Logger;
+}
+/**
+ * Reindex task status from OpenSearch
+ */
+export interface ReindexTaskStatus {
+    /** Task ID */
+    taskId: string;
+    /** Whether task is completed */
+    completed: boolean;
+    /** Number of documents processed */
+    processed: number;
+    /** Total documents to process */
+    total: number;
+    /** Error if any */
+    error?: string;
+}
+/**
+ * Embedding cache statistics
+ */
+export interface EmbeddingCacheStats {
+    /** Number of cache hits */
+    hits: number;
+    /** Number of cache misses */
+    misses: number;
+    /** Current cache size */
+    size: number;
+    /** Hit rate (0-1) */
+    hitRate: number;
+}
+/**
+ * Response cache statistics
+ */
+export interface ResponseCacheStats {
+    /** Total number of cached entries */
+    size: number;
+    /** Number of cache hits */
+    hits: number;
+    /** Number of cache misses */
+    misses: number;
+    /** Hit rate percentage (0-100) */
+    hitRate: number;
+    /** Number of expired entries cleaned up */
+    cleanupCount: number;
+}
+/**
+ * Combined cache statistics response
+ */
+export interface CacheStatsResponse {
+    /** Embedding cache statistics */
+    embedding: EmbeddingCacheStats;
+    /** Response cache statistics */
+    response: ResponseCacheStats;
+    /** Timestamp of stats collection */
+    timestamp: number;
+}
+/**
+ * Search tab configuration for component (uses LucideIcon directly)
+ */
+export interface ComponentSearchTab {
+    id: SearchResultType | "all";
+    label: string;
+    icon: LucideIcon;
+}
+/**
+ * Props for IndexRow component
+ */
+export interface IndexRowProps {
+    index: IndexInfo;
+    canUpdate?: boolean;
+    canDelete?: boolean;
+    isSyncing?: boolean;
+    isDeleting?: boolean;
+    disabled?: boolean;
+    onSync?: () => void;
+    onDelete?: () => void;
+}
+/**
+ * Props for CreateResultRow component
+ */
+export interface CreateResultRowProps {
+    result: CreateResult;
+}
+/**
+ * Props for SyncResultRow component
+ */
+export interface SyncResultRowProps {
+    result: SyncResult;
+}
+/**
+ * Props for SyncProgressCard component
+ */
+export interface SyncProgressCardProps {
+    activeSync: ActiveSync;
+}
+/**
+ * Props for SearchResultItem component
+ */
+export interface SearchResultItemProps {
+    /** The search result to render */
+    result: import("./search.schemas").SearchResult;
+    /** Index of this result in the list */
+    index: number;
+    /** Whether this result is from recent searches */
+    isRecent?: boolean;
+    /** Whether this result is currently selected */
+    isSelected: boolean;
+    /** Callback when the result is selected */
+    onSelect: (result: import("./search.schemas").SearchResult) => void;
+    /** Callback when mouse enters the result */
+    onMouseEnter: (index: number) => void;
+}
+/**
+ * Props for SearchFooter component
+ */
+export interface SearchFooterProps {
+    /** Total number of results */
+    total: number;
+    /** Whether to show the footer */
+    show: boolean;
+}
+/**
+ * Props for SearchErrorState component
+ */
+export interface SearchErrorStateProps {
+    /** Error message to display */
+    error: string;
+    /** Callback when retry is clicked */
+    onRetry: () => void;
+}
+/**
+ * Props for SearchInitialState component
+ */
+export interface SearchInitialStateProps {
+    /** Callback when a suggestion is clicked */
+    onSuggestionClick: (suggestion: string) => void;
+}
+/**
+ * Props for SearchRecentsHeader component
+ */
+export interface SearchRecentsHeaderProps {
+    /** Callback when clear is clicked */
+    onClear: () => void;
+}
+/**
+ * Props for SearchNoResultsState component
+ */
+export interface SearchNoResultsStateProps {
+    /** The query that returned no results */
+    query: string;
+}
+/**
+ * Props for SearchLoadMoreTrigger component
+ */
+export interface SearchLoadMoreTriggerProps {
+    /** Whether more results are being fetched */
+    isFetching: boolean;
+    /** Callback to load more results */
+    onLoadMore: () => void;
+}
+//# sourceMappingURL=search.interfaces.d.ts.map