gthinking 1.2.1 → 2.1.1

package/dist/types/learning.d.ts

@@ -1,62 +1,852 @@
-import { SourceType } from './core';
-export interface LearningContext {
-    id: string;
-    sessionId: string;
-    userId?: string;
-    topic: string;
-    previousInteractions: Interaction[];
-    learnedPatterns: Pattern[];
-    knowledgeGraph: KnowledgeGraph;
-    preferences: UserPreferences;
-}
-export interface Interaction {
-    id: string;
-    timestamp: Date;
-    query: string;
-    response: string;
-    feedback?: Feedback;
-    contextSnapshot: unknown;
-}
-export interface Feedback {
-    rating: number;
-    comments?: string;
-    helpful: boolean;
-    corrections?: string[];
-}
-export interface Pattern {
-    id: string;
-    type: 'query_pattern' | 'response_pattern' | 'error_pattern' | 'success_pattern';
-    pattern: string;
-    frequency: number;
-    successRate: number;
-    lastObserved: Date;
-}
-export interface KnowledgeGraph {
-    nodes: KnowledgeNode[];
-    edges: KnowledgeEdge[];
-    version: number;
-    lastUpdated: Date;
-}
-export interface KnowledgeNode {
-    id: string;
-    label: string;
-    type: 'concept' | 'entity' | 'fact' | 'rule';
-    properties: Record<string, unknown>;
-    confidence: number;
-    sources: string[];
-}
-export interface KnowledgeEdge {
-    from: string;
-    to: string;
-    relation: string;
-    strength: number;
-    evidence: string[];
-}
-export interface UserPreferences {
-    responseStyle: 'concise' | 'detailed' | 'technical' | 'simple';
-    preferredSources: SourceType[];
-    topicInterests: string[];
-    excludedTopics: string[];
-    language: string;
-}
+/**
+ * Learning Types for gthinking v2.0.0
+ * Types for learning and knowledge management functionality
+ */
+import { z } from 'zod';
+/**
+ * Learning Context Schema
+ */
+export declare const LearningContextSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    interactions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        query: z.ZodString;
+        response: z.ZodString;
+        timestamp: z.ZodDate;
+        feedback: z.ZodOptional<z.ZodEnum<["positive", "negative", "neutral"]>>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp?: Date;
+        query?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        response?: string;
+        feedback?: "positive" | "negative" | "neutral";
+    }, {
+        timestamp?: Date;
+        query?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        response?: string;
+        feedback?: "positive" | "negative" | "neutral";
+    }>, "many">>;
+    patterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        frequency: z.ZodNumber;
+        confidence: z.ZodNumber;
+        lastSeen: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        frequency?: number;
+        pattern?: string;
+        lastSeen?: Date;
+    }, {
+        confidence?: number;
+        frequency?: number;
+        pattern?: string;
+        lastSeen?: Date;
+    }>, "many">>;
+    preferences: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    lastAccessed: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    sessionId?: string;
+    interactions?: {
+        timestamp?: Date;
+        query?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        response?: string;
+        feedback?: "positive" | "negative" | "neutral";
+    }[];
+    patterns?: {
+        confidence?: number;
+        frequency?: number;
+        pattern?: string;
+        lastSeen?: Date;
+    }[];
+    preferences?: Record<string, unknown>;
+    lastAccessed?: Date;
+}, {
+    id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    sessionId?: string;
+    interactions?: {
+        timestamp?: Date;
+        query?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        response?: string;
+        feedback?: "positive" | "negative" | "neutral";
+    }[];
+    patterns?: {
+        confidence?: number;
+        frequency?: number;
+        pattern?: string;
+        lastSeen?: Date;
+    }[];
+    preferences?: Record<string, unknown>;
+    lastAccessed?: Date;
+}>;
+/**
+ * Learning Context Type
+ */
+export type LearningContext = z.infer<typeof LearningContextSchema>;
+/**
+ * Knowledge Node Schema
+ */
+export declare const KnowledgeNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    concept: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodString;
+    confidence: z.ZodNumber;
+    sources: z.ZodArray<z.ZodString, "many">;
+    relatedNodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    accessCount: z.ZodDefault<z.ZodNumber>;
+    successRate: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    sources?: string[];
+    accessCount?: number;
+    category?: string;
+    concept?: string;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    relatedNodes?: string[];
+    successRate?: number;
+}, {
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    sources?: string[];
+    accessCount?: number;
+    category?: string;
+    concept?: string;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    relatedNodes?: string[];
+    successRate?: number;
+}>;
+/**
+ * Knowledge Node Type
+ */
+export type KnowledgeNode = z.infer<typeof KnowledgeNodeSchema>;
+/**
+ * Knowledge Edge Schema
+ */
+export declare const KnowledgeEdgeSchema: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    relation: z.ZodString;
+    strength: z.ZodNumber;
+    bidirectional: z.ZodDefault<z.ZodBoolean>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    from?: string;
+    to?: string;
+    strength?: number;
+    relation?: string;
+    bidirectional?: boolean;
+}, {
+    id?: string;
+    metadata?: Record<string, unknown>;
+    from?: string;
+    to?: string;
+    strength?: number;
+    relation?: string;
+    bidirectional?: boolean;
+}>;
+/**
+ * Knowledge Edge Type
+ */
+export type KnowledgeEdge = z.infer<typeof KnowledgeEdgeSchema>;
+/**
+ * Knowledge Graph Schema
+ */
+export declare const KnowledgeGraphSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        concept: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        sources: z.ZodArray<z.ZodString, "many">;
+        relatedNodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        accessCount: z.ZodDefault<z.ZodNumber>;
+        successRate: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }, {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodString;
+        relation: z.ZodString;
+        strength: z.ZodNumber;
+        bidirectional: z.ZodDefault<z.ZodBoolean>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        from?: string;
+        to?: string;
+        strength?: number;
+        relation?: string;
+        bidirectional?: boolean;
+    }, {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        from?: string;
+        to?: string;
+        strength?: number;
+        relation?: string;
+        bidirectional?: boolean;
+    }>, "many">;
+    categories: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    version: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name?: string;
+    id?: string;
+    nodes?: {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    version?: number;
+    edges?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        from?: string;
+        to?: string;
+        strength?: number;
+        relation?: string;
+        bidirectional?: boolean;
+    }[];
+    categories?: string[];
+}, {
+    name?: string;
+    id?: string;
+    nodes?: {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }[];
+    createdAt?: Date;
+    updatedAt?: Date;
+    version?: number;
+    edges?: {
+        id?: string;
+        metadata?: Record<string, unknown>;
+        from?: string;
+        to?: string;
+        strength?: number;
+        relation?: string;
+        bidirectional?: boolean;
+    }[];
+    categories?: string[];
+}>;
+/**
+ * Knowledge Graph Type
+ */
+export type KnowledgeGraph = z.infer<typeof KnowledgeGraphSchema>;
+/**
+ * Pattern Schema
+ */
+export declare const PatternSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    examples: z.ZodArray<z.ZodString, "many">;
+    frequency: z.ZodNumber;
+    confidence: z.ZodNumber;
+    firstSeen: z.ZodDate;
+    lastSeen: z.ZodDate;
+    successRate: z.ZodDefault<z.ZodNumber>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    name?: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    frequency?: number;
+    description?: string;
+    lastSeen?: Date;
+    successRate?: number;
+    examples?: string[];
+    firstSeen?: Date;
+}, {
+    confidence?: number;
+    name?: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    frequency?: number;
+    description?: string;
+    lastSeen?: Date;
+    successRate?: number;
+    examples?: string[];
+    firstSeen?: Date;
+}>;
+/**
+ * Pattern Type
+ */
+export type Pattern = z.infer<typeof PatternSchema>;
+/**
+ * User Preference Schema
+ */
+export declare const UserPreferenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    key: z.ZodString;
+    value: z.ZodUnknown;
+    confidence: z.ZodDefault<z.ZodNumber>;
+    learnedFrom: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    updatedAt: z.ZodDate;
+}, "strip", z.ZodTypeAny, {
+    value?: unknown;
+    confidence?: number;
+    id?: string;
+    key?: string;
+    category?: string;
+    updatedAt?: Date;
+    learnedFrom?: string[];
+}, {
+    value?: unknown;
+    confidence?: number;
+    id?: string;
+    key?: string;
+    category?: string;
+    updatedAt?: Date;
+    learnedFrom?: string[];
+}>;
+/**
+ * User Preference Type
+ */
+export type UserPreference = z.infer<typeof UserPreferenceSchema>;
+/**
+ * Interaction Record Schema
+ */
+export declare const InteractionRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    sessionId: z.ZodString;
+    query: z.ZodString;
+    response: z.ZodString;
+    thinkingStages: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    duration: z.ZodNumber;
+    timestamp: z.ZodDate;
+    feedback: z.ZodOptional<z.ZodObject<{
+        rating: z.ZodOptional<z.ZodNumber>;
+        comment: z.ZodOptional<z.ZodString>;
+        helpful: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        rating?: number;
+        comment?: string;
+        helpful?: boolean;
+    }, {
+        rating?: number;
+        comment?: string;
+        helpful?: boolean;
+    }>>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    timestamp?: Date;
+    duration?: number;
+    query?: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    response?: string;
+    feedback?: {
+        rating?: number;
+        comment?: string;
+        helpful?: boolean;
+    };
+    thinkingStages?: string[];
+}, {
+    timestamp?: Date;
+    duration?: number;
+    query?: string;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    sessionId?: string;
+    response?: string;
+    feedback?: {
+        rating?: number;
+        comment?: string;
+        helpful?: boolean;
+    };
+    thinkingStages?: string[];
+}>;
+/**
+ * Interaction Record Type
+ */
+export type InteractionRecord = z.infer<typeof InteractionRecordSchema>;
+/**
+ * Learning Result Schema
+ */
+export declare const LearningResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodDate;
+    duration: z.ZodNumber;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    context: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        sessionId: z.ZodString;
+        interactions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            query: z.ZodString;
+            response: z.ZodString;
+            timestamp: z.ZodDate;
+            feedback: z.ZodOptional<z.ZodEnum<["positive", "negative", "neutral"]>>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp?: Date;
+            query?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            response?: string;
+            feedback?: "positive" | "negative" | "neutral";
+        }, {
+            timestamp?: Date;
+            query?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            response?: string;
+            feedback?: "positive" | "negative" | "neutral";
+        }>, "many">>;
+        patterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            frequency: z.ZodNumber;
+            confidence: z.ZodNumber;
+            lastSeen: z.ZodDate;
+        }, "strip", z.ZodTypeAny, {
+            confidence?: number;
+            frequency?: number;
+            pattern?: string;
+            lastSeen?: Date;
+        }, {
+            confidence?: number;
+            frequency?: number;
+            pattern?: string;
+            lastSeen?: Date;
+        }>, "many">>;
+        preferences: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        lastAccessed: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        sessionId?: string;
+        interactions?: {
+            timestamp?: Date;
+            query?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            response?: string;
+            feedback?: "positive" | "negative" | "neutral";
+        }[];
+        patterns?: {
+            confidence?: number;
+            frequency?: number;
+            pattern?: string;
+            lastSeen?: Date;
+        }[];
+        preferences?: Record<string, unknown>;
+        lastAccessed?: Date;
+    }, {
+        id?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        sessionId?: string;
+        interactions?: {
+            timestamp?: Date;
+            query?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            response?: string;
+            feedback?: "positive" | "negative" | "neutral";
+        }[];
+        patterns?: {
+            confidence?: number;
+            frequency?: number;
+            pattern?: string;
+            lastSeen?: Date;
+        }[];
+        preferences?: Record<string, unknown>;
+        lastAccessed?: Date;
+    }>>;
+    patterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        examples: z.ZodArray<z.ZodString, "many">;
+        frequency: z.ZodNumber;
+        confidence: z.ZodNumber;
+        firstSeen: z.ZodDate;
+        lastSeen: z.ZodDate;
+        successRate: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        frequency?: number;
+        description?: string;
+        lastSeen?: Date;
+        successRate?: number;
+        examples?: string[];
+        firstSeen?: Date;
+    }, {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        frequency?: number;
+        description?: string;
+        lastSeen?: Date;
+        successRate?: number;
+        examples?: string[];
+        firstSeen?: Date;
+    }>, "many">>;
+    preferences: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        key: z.ZodString;
+        value: z.ZodUnknown;
+        confidence: z.ZodDefault<z.ZodNumber>;
+        learnedFrom: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        updatedAt: z.ZodDate;
+    }, "strip", z.ZodTypeAny, {
+        value?: unknown;
+        confidence?: number;
+        id?: string;
+        key?: string;
+        category?: string;
+        updatedAt?: Date;
+        learnedFrom?: string[];
+    }, {
+        value?: unknown;
+        confidence?: number;
+        id?: string;
+        key?: string;
+        category?: string;
+        updatedAt?: Date;
+        learnedFrom?: string[];
+    }>, "many">>;
+    relevantKnowledge: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        concept: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        sources: z.ZodArray<z.ZodString, "many">;
+        relatedNodes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+        accessCount: z.ZodDefault<z.ZodNumber>;
+        successRate: z.ZodDefault<z.ZodNumber>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }, {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }>, "many">>;
+    insights: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    context?: {
+        id?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        sessionId?: string;
+        interactions?: {
+            timestamp?: Date;
+            query?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            response?: string;
+            feedback?: "positive" | "negative" | "neutral";
+        }[];
+        patterns?: {
+            confidence?: number;
+            frequency?: number;
+            pattern?: string;
+            lastSeen?: Date;
+        }[];
+        preferences?: Record<string, unknown>;
+        lastAccessed?: Date;
+    };
+    insights?: string[];
+    patterns?: {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        frequency?: number;
+        description?: string;
+        lastSeen?: Date;
+        successRate?: number;
+        examples?: string[];
+        firstSeen?: Date;
+    }[];
+    preferences?: {
+        value?: unknown;
+        confidence?: number;
+        id?: string;
+        key?: string;
+        category?: string;
+        updatedAt?: Date;
+        learnedFrom?: string[];
+    }[];
+    relevantKnowledge?: {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }[];
+}, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    context?: {
+        id?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        sessionId?: string;
+        interactions?: {
+            timestamp?: Date;
+            query?: string;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            response?: string;
+            feedback?: "positive" | "negative" | "neutral";
+        }[];
+        patterns?: {
+            confidence?: number;
+            frequency?: number;
+            pattern?: string;
+            lastSeen?: Date;
+        }[];
+        preferences?: Record<string, unknown>;
+        lastAccessed?: Date;
+    };
+    insights?: string[];
+    patterns?: {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        frequency?: number;
+        description?: string;
+        lastSeen?: Date;
+        successRate?: number;
+        examples?: string[];
+        firstSeen?: Date;
+    }[];
+    preferences?: {
+        value?: unknown;
+        confidence?: number;
+        id?: string;
+        key?: string;
+        category?: string;
+        updatedAt?: Date;
+        learnedFrom?: string[];
+    }[];
+    relevantKnowledge?: {
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        sources?: string[];
+        accessCount?: number;
+        category?: string;
+        concept?: string;
+        description?: string;
+        createdAt?: Date;
+        updatedAt?: Date;
+        relatedNodes?: string[];
+        successRate?: number;
+    }[];
+}>;
+/**
+ * Learning Result Type
+ */
+export type LearningResult = z.infer<typeof LearningResultSchema>;
+/**
+ * Persistence Config Schema
+ */
+export declare const PersistenceConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    strategy: z.ZodDefault<z.ZodEnum<["memory", "file", "redis", "database"]>>;
+    autoSave: z.ZodDefault<z.ZodBoolean>;
+    autoSaveInterval: z.ZodDefault<z.ZodNumber>;
+    maxContexts: z.ZodDefault<z.ZodNumber>;
+    maxPatterns: z.ZodDefault<z.ZodNumber>;
+    maxKnowledgeNodes: z.ZodDefault<z.ZodNumber>;
+    ttl: z.ZodDefault<z.ZodNumber>;
+    compression: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    ttl?: number;
+    enabled?: boolean;
+    strategy?: "memory" | "file" | "redis" | "database";
+    autoSave?: boolean;
+    autoSaveInterval?: number;
+    maxContexts?: number;
+    maxPatterns?: number;
+    maxKnowledgeNodes?: number;
+    compression?: boolean;
+}, {
+    ttl?: number;
+    enabled?: boolean;
+    strategy?: "memory" | "file" | "redis" | "database";
+    autoSave?: boolean;
+    autoSaveInterval?: number;
+    maxContexts?: number;
+    maxPatterns?: number;
+    maxKnowledgeNodes?: number;
+    compression?: boolean;
+}>;
+/**
+ * Persistence Config Type
+ */
+export type PersistenceConfig = z.infer<typeof PersistenceConfigSchema>;
+/**
+ * Query Context Request Schema
+ */
+export declare const QueryContextRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    maxInteractions: z.ZodDefault<z.ZodNumber>;
+    maxPatterns: z.ZodDefault<z.ZodNumber>;
+    maxKnowledgeNodes: z.ZodDefault<z.ZodNumber>;
+    includePreferences: z.ZodDefault<z.ZodBoolean>;
+    similarityThreshold: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+    sessionId?: string;
+    maxPatterns?: number;
+    maxKnowledgeNodes?: number;
+    maxInteractions?: number;
+    includePreferences?: boolean;
+    similarityThreshold?: number;
+}, {
+    query?: string;
+    sessionId?: string;
+    maxPatterns?: number;
+    maxKnowledgeNodes?: number;
+    maxInteractions?: number;
+    includePreferences?: boolean;
+    similarityThreshold?: number;
+}>;
+/**
+ * Query Context Request Type
+ */
+export type QueryContextRequest = z.infer<typeof QueryContextRequestSchema>;
 //# sourceMappingURL=learning.d.ts.map