gthinking 1.3.0 → 2.1.1

package/dist/types/search.d.ts

@@ -1,56 +1,984 @@
+/**
+ * Search Types for gthinking v2.0.0
+ * Types for search and discovery functionality
+ */
+import { z } from 'zod';
 import { SourceType } from './core';
-export interface SearchQuery {
-    id: string;
-    query: string;
-    sources: SourceType[];
-    filters: SearchFilters;
-    maxResults: number;
-    timeout: number;
-    timestamp: Date;
-}
-export interface SearchFilters {
-    dateRange?: {
-        start: Date;
-        end: Date;
-    };
-    domains?: string[];
-    excludeDomains?: string[];
-    language?: string;
-    contentType?: ('article' | 'video' | 'image' | 'pdf' | 'forum')[];
-    minCredibility?: number;
-}
-export interface SearchResult {
-    id: string;
-    title: string;
-    url: string;
-    snippet: string;
-    source: SourceType;
-    credibility: number;
-    relevance: number;
-    timestamp: Date;
-    metadata: ResultMetadata;
-}
-export interface ResultMetadata {
-    author?: string;
-    publishDate?: Date;
-    wordCount?: number;
-    readingTime?: number;
-    relatedTopics?: string[];
-    citations?: number;
-}
-export interface SearchSession {
-    id: string;
-    queries: SearchQuery[];
-    results: SearchResult[];
-    aggregatedResults: AggregatedResult[];
-    startTime: Date;
-    endTime?: Date;
-}
-export interface AggregatedResult {
-    topic: string;
-    results: SearchResult[];
-    consensusScore: number;
-    conflictingInfo: boolean;
-    keyInsights: string[];
+/**
+ * Search Provider Enum
+ */
+export declare enum SearchProvider {
+    GOOGLE = "google",
+    BING = "bing",
+    BRAVE = "brave",
+    DUCKDUCKGO = "duckduckgo",
+    KNOWLEDGE_BASE = "knowledge_base",
+    CACHE = "cache"
 }
+/**
+ * Search Provider Schema
+ */
+export declare const SearchProviderSchema: z.ZodNativeEnum<typeof SearchProvider>;
+/**
+ * Search Query Schema
+ */
+export declare const SearchQuerySchema: z.ZodObject<{
+    query: z.ZodString;
+    maxResults: z.ZodDefault<z.ZodNumber>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof SearchProvider>, "many">>;
+    filters: z.ZodDefault<z.ZodObject<{
+        dateRange: z.ZodOptional<z.ZodObject<{
+            from: z.ZodOptional<z.ZodDate>;
+            to: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            from?: Date;
+            to?: Date;
+        }, {
+            from?: Date;
+            to?: Date;
+        }>>;
+        language: z.ZodDefault<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        safeSearch: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    }, {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    }>>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number;
+    query?: string;
+    maxResults?: number;
+    sources?: SearchProvider[];
+    filters?: {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    };
+}, {
+    timeout?: number;
+    query?: string;
+    maxResults?: number;
+    sources?: SearchProvider[];
+    filters?: {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    };
+}>;
+/**
+ * Search Query Type
+ */
+export type SearchQuery = z.infer<typeof SearchQuerySchema>;
+/**
+ * Search Result Item Schema
+ */
+export declare const SearchResultItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodString;
+    snippet: z.ZodString;
+    source: z.ZodNativeEnum<typeof SearchProvider>;
+    sourceType: z.ZodNativeEnum<typeof SourceType>;
+    publishedDate: z.ZodOptional<z.ZodDate>;
+    credibility: z.ZodDefault<z.ZodNumber>;
+    relevance: z.ZodDefault<z.ZodNumber>;
+    engagement: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    title?: string;
+    url?: string;
+    snippet?: string;
+    source?: SearchProvider;
+    sourceType?: SourceType;
+    publishedDate?: Date;
+    credibility?: number;
+    relevance?: number;
+    engagement?: number;
+}, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    title?: string;
+    url?: string;
+    snippet?: string;
+    source?: SearchProvider;
+    sourceType?: SourceType;
+    publishedDate?: Date;
+    credibility?: number;
+    relevance?: number;
+    engagement?: number;
+}>;
+/**
+ * Search Result Item Type
+ */
+export type SearchResultItem = z.infer<typeof SearchResultItemSchema>;
+/**
+ * Search Result Schema
+ */
+export declare const SearchResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodDate;
+    duration: z.ZodNumber;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    query: z.ZodObject<{
+        query: z.ZodString;
+        maxResults: z.ZodDefault<z.ZodNumber>;
+        sources: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof SearchProvider>, "many">>;
+        filters: z.ZodDefault<z.ZodObject<{
+            dateRange: z.ZodOptional<z.ZodObject<{
+                from: z.ZodOptional<z.ZodDate>;
+                to: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                from?: Date;
+                to?: Date;
+            }, {
+                from?: Date;
+                to?: Date;
+            }>>;
+            language: z.ZodDefault<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            safeSearch: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        }, {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        }>>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    }, {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodString;
+        snippet: z.ZodString;
+        source: z.ZodNativeEnum<typeof SearchProvider>;
+        sourceType: z.ZodNativeEnum<typeof SourceType>;
+        publishedDate: z.ZodOptional<z.ZodDate>;
+        credibility: z.ZodDefault<z.ZodNumber>;
+        relevance: z.ZodDefault<z.ZodNumber>;
+        engagement: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }>, "many">;
+    totalResults: z.ZodNumber;
+    searchTime: z.ZodNumber;
+    provider: z.ZodNativeEnum<typeof SearchProvider>;
+}, "strip", z.ZodTypeAny, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    query?: {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    };
+    items?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }[];
+    totalResults?: number;
+    searchTime?: number;
+    provider?: SearchProvider;
+}, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    query?: {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    };
+    items?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }[];
+    totalResults?: number;
+    searchTime?: number;
+    provider?: SearchProvider;
+}>;
+/**
+ * Search Result Type
+ */
+export type SearchResult = z.infer<typeof SearchResultSchema>;
+/**
+ * Aggregated Result Schema
+ */
+export declare const AggregatedResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    topic: z.ZodString;
+    summary: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        url: z.ZodString;
+        snippet: z.ZodString;
+        source: z.ZodNativeEnum<typeof SearchProvider>;
+        sourceType: z.ZodNativeEnum<typeof SourceType>;
+        publishedDate: z.ZodOptional<z.ZodDate>;
+        credibility: z.ZodDefault<z.ZodNumber>;
+        relevance: z.ZodDefault<z.ZodNumber>;
+        engagement: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }>, "many">;
+    consensusScore: z.ZodNumber;
+    conflicts: z.ZodArray<z.ZodObject<{
+        claim1: z.ZodString;
+        claim2: z.ZodString;
+        sources: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        sources?: string[];
+        claim1?: string;
+        claim2?: string;
+    }, {
+        sources?: string[];
+        claim1?: string;
+        claim2?: string;
+    }>, "many">;
+    keyInsights: z.ZodArray<z.ZodString, "many">;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    timestamp?: Date;
+    id?: string;
+    sources?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }[];
+    topic?: string;
+    summary?: string;
+    consensusScore?: number;
+    conflicts?: {
+        sources?: string[];
+        claim1?: string;
+        claim2?: string;
+    }[];
+    keyInsights?: string[];
+}, {
+    confidence?: number;
+    timestamp?: Date;
+    id?: string;
+    sources?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        title?: string;
+        url?: string;
+        snippet?: string;
+        source?: SearchProvider;
+        sourceType?: SourceType;
+        publishedDate?: Date;
+        credibility?: number;
+        relevance?: number;
+        engagement?: number;
+    }[];
+    topic?: string;
+    summary?: string;
+    consensusScore?: number;
+    conflicts?: {
+        sources?: string[];
+        claim1?: string;
+        claim2?: string;
+    }[];
+    keyInsights?: string[];
+}>;
+/**
+ * Aggregated Result Type
+ */
+export type AggregatedResult = z.infer<typeof AggregatedResultSchema>;
+/**
+ * Multi-Search Request Schema
+ */
+export declare const MultiSearchRequestSchema: z.ZodObject<{
+    queries: z.ZodArray<z.ZodString, "many">;
+    options: z.ZodDefault<z.ZodDefault<z.ZodObject<{
+        dateRange: z.ZodOptional<z.ZodObject<{
+            from: z.ZodOptional<z.ZodDate>;
+            to: z.ZodOptional<z.ZodDate>;
+        }, "strip", z.ZodTypeAny, {
+            from?: Date;
+            to?: Date;
+        }, {
+            from?: Date;
+            to?: Date;
+        }>>;
+        language: z.ZodDefault<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        safeSearch: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    }, {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    };
+    queries?: string[];
+}, {
+    options?: {
+        dateRange?: {
+            from?: Date;
+            to?: Date;
+        };
+        language?: string;
+        region?: string;
+        safeSearch?: boolean;
+    };
+    queries?: string[];
+}>;
+/**
+ * Multi-Search Request Type
+ */
+export type MultiSearchRequest = z.infer<typeof MultiSearchRequestSchema>;
+/**
+ * Search Cache Entry Schema
+ */
+export declare const SearchCacheEntrySchema: z.ZodObject<{
+    key: z.ZodString;
+    query: z.ZodObject<{
+        query: z.ZodString;
+        maxResults: z.ZodDefault<z.ZodNumber>;
+        sources: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof SearchProvider>, "many">>;
+        filters: z.ZodDefault<z.ZodObject<{
+            dateRange: z.ZodOptional<z.ZodObject<{
+                from: z.ZodOptional<z.ZodDate>;
+                to: z.ZodOptional<z.ZodDate>;
+            }, "strip", z.ZodTypeAny, {
+                from?: Date;
+                to?: Date;
+            }, {
+                from?: Date;
+                to?: Date;
+            }>>;
+            language: z.ZodDefault<z.ZodString>;
+            region: z.ZodOptional<z.ZodString>;
+            safeSearch: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        }, {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        }>>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    }, {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    }>;
+    result: z.ZodObject<{
+        success: z.ZodBoolean;
+        confidence: z.ZodNumber;
+        timestamp: z.ZodDate;
+        duration: z.ZodNumber;
+        errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    } & {
+        query: z.ZodObject<{
+            query: z.ZodString;
+            maxResults: z.ZodDefault<z.ZodNumber>;
+            sources: z.ZodDefault<z.ZodArray<z.ZodNativeEnum<typeof SearchProvider>, "many">>;
+            filters: z.ZodDefault<z.ZodObject<{
+                dateRange: z.ZodOptional<z.ZodObject<{
+                    from: z.ZodOptional<z.ZodDate>;
+                    to: z.ZodOptional<z.ZodDate>;
+                }, "strip", z.ZodTypeAny, {
+                    from?: Date;
+                    to?: Date;
+                }, {
+                    from?: Date;
+                    to?: Date;
+                }>>;
+                language: z.ZodDefault<z.ZodString>;
+                region: z.ZodOptional<z.ZodString>;
+                safeSearch: z.ZodDefault<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            }, {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            }>>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            timeout?: number;
+            query?: string;
+            maxResults?: number;
+            sources?: SearchProvider[];
+            filters?: {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            };
+        }, {
+            timeout?: number;
+            query?: string;
+            maxResults?: number;
+            sources?: SearchProvider[];
+            filters?: {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            };
+        }>;
+        items: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            url: z.ZodString;
+            snippet: z.ZodString;
+            source: z.ZodNativeEnum<typeof SearchProvider>;
+            sourceType: z.ZodNativeEnum<typeof SourceType>;
+            publishedDate: z.ZodOptional<z.ZodDate>;
+            credibility: z.ZodDefault<z.ZodNumber>;
+            relevance: z.ZodDefault<z.ZodNumber>;
+            engagement: z.ZodDefault<z.ZodNumber>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            title?: string;
+            url?: string;
+            snippet?: string;
+            source?: SearchProvider;
+            sourceType?: SourceType;
+            publishedDate?: Date;
+            credibility?: number;
+            relevance?: number;
+            engagement?: number;
+        }, {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            title?: string;
+            url?: string;
+            snippet?: string;
+            source?: SearchProvider;
+            sourceType?: SourceType;
+            publishedDate?: Date;
+            credibility?: number;
+            relevance?: number;
+            engagement?: number;
+        }>, "many">;
+        totalResults: z.ZodNumber;
+        searchTime: z.ZodNumber;
+        provider: z.ZodNativeEnum<typeof SearchProvider>;
+    }, "strip", z.ZodTypeAny, {
+        success?: boolean;
+        confidence?: number;
+        timestamp?: Date;
+        duration?: number;
+        errors?: string[];
+        query?: {
+            timeout?: number;
+            query?: string;
+            maxResults?: number;
+            sources?: SearchProvider[];
+            filters?: {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            };
+        };
+        items?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            title?: string;
+            url?: string;
+            snippet?: string;
+            source?: SearchProvider;
+            sourceType?: SourceType;
+            publishedDate?: Date;
+            credibility?: number;
+            relevance?: number;
+            engagement?: number;
+        }[];
+        totalResults?: number;
+        searchTime?: number;
+        provider?: SearchProvider;
+    }, {
+        success?: boolean;
+        confidence?: number;
+        timestamp?: Date;
+        duration?: number;
+        errors?: string[];
+        query?: {
+            timeout?: number;
+            query?: string;
+            maxResults?: number;
+            sources?: SearchProvider[];
+            filters?: {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            };
+        };
+        items?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            title?: string;
+            url?: string;
+            snippet?: string;
+            source?: SearchProvider;
+            sourceType?: SourceType;
+            publishedDate?: Date;
+            credibility?: number;
+            relevance?: number;
+            engagement?: number;
+        }[];
+        totalResults?: number;
+        searchTime?: number;
+        provider?: SearchProvider;
+    }>;
+    timestamp: z.ZodDate;
+    ttl: z.ZodNumber;
+    accessCount: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timestamp?: Date;
+    query?: {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    };
+    key?: string;
+    result?: {
+        success?: boolean;
+        confidence?: number;
+        timestamp?: Date;
+        duration?: number;
+        errors?: string[];
+        query?: {
+            timeout?: number;
+            query?: string;
+            maxResults?: number;
+            sources?: SearchProvider[];
+            filters?: {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            };
+        };
+        items?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            title?: string;
+            url?: string;
+            snippet?: string;
+            source?: SearchProvider;
+            sourceType?: SourceType;
+            publishedDate?: Date;
+            credibility?: number;
+            relevance?: number;
+            engagement?: number;
+        }[];
+        totalResults?: number;
+        searchTime?: number;
+        provider?: SearchProvider;
+    };
+    ttl?: number;
+    accessCount?: number;
+}, {
+    timestamp?: Date;
+    query?: {
+        timeout?: number;
+        query?: string;
+        maxResults?: number;
+        sources?: SearchProvider[];
+        filters?: {
+            dateRange?: {
+                from?: Date;
+                to?: Date;
+            };
+            language?: string;
+            region?: string;
+            safeSearch?: boolean;
+        };
+    };
+    key?: string;
+    result?: {
+        success?: boolean;
+        confidence?: number;
+        timestamp?: Date;
+        duration?: number;
+        errors?: string[];
+        query?: {
+            timeout?: number;
+            query?: string;
+            maxResults?: number;
+            sources?: SearchProvider[];
+            filters?: {
+                dateRange?: {
+                    from?: Date;
+                    to?: Date;
+                };
+                language?: string;
+                region?: string;
+                safeSearch?: boolean;
+            };
+        };
+        items?: {
+            id?: string;
+            metadata?: Record<string, unknown>;
+            title?: string;
+            url?: string;
+            snippet?: string;
+            source?: SearchProvider;
+            sourceType?: SourceType;
+            publishedDate?: Date;
+            credibility?: number;
+            relevance?: number;
+            engagement?: number;
+        }[];
+        totalResults?: number;
+        searchTime?: number;
+        provider?: SearchProvider;
+    };
+    ttl?: number;
+    accessCount?: number;
+}>;
+/**
+ * Search Cache Entry Type
+ */
+export type SearchCacheEntry = z.infer<typeof SearchCacheEntrySchema>;
+/**
+ * Knowledge Base Entry Schema
+ */
+export declare const KnowledgeBaseEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    content: z.ZodString;
+    category: z.ZodString;
+    tags: z.ZodArray<z.ZodString, "many">;
+    credibility: z.ZodNumber;
+    lastUpdated: z.ZodDate;
+    source: z.ZodString;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    title?: string;
+    source?: string;
+    credibility?: number;
+    content?: string;
+    category?: string;
+    tags?: string[];
+    lastUpdated?: Date;
+}, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    title?: string;
+    source?: string;
+    credibility?: number;
+    content?: string;
+    category?: string;
+    tags?: string[];
+    lastUpdated?: Date;
+}>;
+/**
+ * Knowledge Base Entry Type
+ */
+export type KnowledgeBaseEntry = z.infer<typeof KnowledgeBaseEntrySchema>;
+/**
+ * Web Search Config Schema
+ */
+export declare const WebSearchConfigSchema: z.ZodObject<{
+    provider: z.ZodNativeEnum<typeof SearchProvider>;
+    apiKey: z.ZodString;
+    baseUrl: z.ZodOptional<z.ZodString>;
+    rateLimitPerSecond: z.ZodDefault<z.ZodNumber>;
+    maxRetries: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout?: number;
+    maxRetries?: number;
+    provider?: SearchProvider;
+    apiKey?: string;
+    baseUrl?: string;
+    rateLimitPerSecond?: number;
+}, {
+    timeout?: number;
+    maxRetries?: number;
+    provider?: SearchProvider;
+    apiKey?: string;
+    baseUrl?: string;
+    rateLimitPerSecond?: number;
+}>;
+/**
+ * Web Search Config Type
+ */
+export type WebSearchConfig = z.infer<typeof WebSearchConfigSchema>;
+/**
+ * Search Ranking Weights Schema
+ */
+export declare const SearchRankingWeightsSchema: z.ZodObject<{
+    relevance: z.ZodDefault<z.ZodNumber>;
+    credibility: z.ZodDefault<z.ZodNumber>;
+    freshness: z.ZodDefault<z.ZodNumber>;
+    engagement: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    credibility?: number;
+    relevance?: number;
+    engagement?: number;
+    freshness?: number;
+}, {
+    credibility?: number;
+    relevance?: number;
+    engagement?: number;
+    freshness?: number;
+}>;
+/**
+ * Search Ranking Weights Type
+ */
+export type SearchRankingWeights = z.infer<typeof SearchRankingWeightsSchema>;
 //# sourceMappingURL=search.d.ts.map