@soulcraft/brainy 1.4.0 → 2.0.0

package/dist/brainyData.d.ts

@@ -5,13 +5,13 @@
 import { HNSWIndex } from './hnsw/hnswIndex.js';
 import { HNSWIndexOptimized, HNSWOptimizedConfig } from './hnsw/hnswIndexOptimized.js';
 import { DistanceFunction, GraphVerb, EmbeddingFunction, HNSWConfig, SearchResult, SearchCursor, PaginatedSearchResult, StorageAdapter, Vector, VectorDocument } from './coreTypes.js';
-import { MetadataIndexManager, MetadataIndexConfig } from './utils/metadataIndex.js';
+import { MetadataIndexConfig } from './utils/metadataIndex.js';
 import { NounType, VerbType } from './types/graphTypes.js';
-import { WebSocketConnection, IAugmentation } from './types/augmentations.js';
+import { WebSocketConnection } from './types/augmentations.js';
 import { BrainyDataInterface } from './types/brainyDataInterface.js';
 import { DistributedConfig } from './types/distributedTypes.js';
 import { SearchCacheConfig } from './utils/searchCache.js';
-import { AugmentationManager } from './augmentationManager.js';
+import { TripleQuery, TripleResult } from './triple/TripleIntelligence.js';
 export interface BrainyDataConfig {
     /**
      * HNSW index configuration
@@ -296,10 +296,37 @@ export interface BrainyDataConfig {
             prefetchStrategy?: 'conservative' | 'moderate' | 'aggressive';
         };
     };
+    /**
+     * Batch processing configuration for enterprise-scale throughput
+     * Automatically batches operations for 10-50x performance improvement
+     * Critical for processing millions of operations efficiently
+     */
+    batchSize?: number;
+    batchWaitTime?: number;
+    /**
+     * Real-time streaming configuration for WebSocket/WebRTC
+     * Enables live data broadcasting to thousands of connected clients
+     * Essential for real-time applications like Bluesky firehose
+     */
+    realtime?: {
+        websocket?: {
+            enabled?: boolean;
+            port?: number;
+            maxConnections?: number;
+        };
+        webrtc?: {
+            enabled?: boolean;
+            maxPeers?: number;
+        };
+        broadcasting?: {
+            operations?: string[];
+            includeData?: boolean;
+        };
+    };
     /**
      * Intelligent verb scoring configuration
      * Automatically generates weight and confidence scores for verb relationships
-     * Off by default - enable by setting enabled: true
+     * Enabled by default for better relationship quality
      */
     intelligentVerbScoring?: {
         /**
@@ -348,11 +375,28 @@ export interface BrainyDataConfig {
          */
         learningRate?: number;
     };
+    /**
+     * Entity registry configuration for fast external-ID to UUID mapping
+     * Provides lightning-fast lookups for streaming data processing
+     */
+    entityCacheSize?: number;
+    entityCacheTTL?: number;
+    /**
+     * Statistics collection configuration
+     * When false, disables metrics collection. When true or config object, enables with options.
+     * Default: true
+     */
+    statistics?: boolean;
+    /**
+     * Health monitoring configuration
+     * When false, disables health monitoring. When true or config object, enables with options.
+     * Default: false (enabled automatically for distributed setups)
+     */
+    health?: boolean;
 }
 export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
-    index: HNSWIndex | HNSWIndexOptimized;
+    hnswIndex: HNSWIndex | HNSWIndexOptimized;
     private storage;
-    metadataIndex: MetadataIndexManager | null;
     private isInitialized;
     private isInitializing;
     private embeddingFunction;
@@ -369,12 +413,17 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private _dimensions;
     private loggingConfig;
     private defaultService;
-    private searchCache;
     /**
-     * Type-safe augmentation management
-     * Access all augmentation operations through this property
+     * Enterprise augmentation system
+     * Handles WAL, connection pooling, batching, streaming, and intelligent scoring
+     */
+    private augmentations;
+    /**
+     * Neural similarity API for semantic operations
      */
-    readonly augmentations: AugmentationManager;
+    private _neural?;
+    private _tripleEngine?;
+    private _nlpProcessor?;
     private cacheAutoConfigurator;
     private timeoutConfig;
     private retryConfig;
@@ -385,16 +434,17 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     private lastUpdateTime;
     private lastKnownNounCount;
     private remoteServerConfig;
-    private serverSearchConduit;
-    private serverConnection;
     private intelligentVerbScoring;
     private distributedConfig;
     private configManager;
     private partitioner;
     private operationalMode;
     private domainDetector;
-    private healthMonitor;
-    private statisticsCollector;
+    private get cache();
+    private get index();
+    private get metadataIndex();
+    private get metrics();
+    private get monitoring();
     /**
      * Get the vector dimensions
      */
@@ -407,6 +457,10 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * Get the efConstruction parameter from HNSW configuration
      */
     get efConstruction(): number;
+    /**
+     * Check if BrainyData has been initialized
+     */
+    get initialized(): boolean;
     /**
      * Create a new vector database
      */
@@ -415,6 +469,21 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * Check if the database is in read-only mode and throw an error if it is
      * @throws Error if the database is in read-only mode
      */
+    /**
+     * Register default augmentations without initializing them
+     * Phase 1 of two-phase initialization
+     */
+    private registerDefaultAugmentations;
+    /**
+     * Resolve storage from augmentation or config
+     * Phase 2 of two-phase initialization
+     */
+    private resolveStorage;
+    /**
+     * Initialize the augmentation system with full context
+     * Phase 3 of two-phase initialization
+     */
+    private initializeAugmentations;
     private checkReadOnly;
     /**
      * Check if the database is frozen and throw an error if it is
@@ -564,28 +633,6 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
         service?: string;
         process?: 'auto' | 'literal' | 'neural';
     }): Promise<string>;
-    /**
-     * Add a text item to the database with automatic embedding
-     * This is a convenience method for adding text data with metadata
-     * @param text Text data to add
-     * @param metadata Metadata to associate with the text
-     * @param options Additional options
-     * @returns The ID of the added item
-     */
-    addItem(text: string, metadata?: T, options?: {
-        addToRemote?: boolean;
-        id?: string;
-    }): Promise<string>;
-    /**
-     * Add data to both local and remote Brainy instances
-     * @param vectorOrData Vector or data to add
-     * @param metadata Optional metadata to associate with the vector
-     * @param options Additional options
-     * @returns The ID of the added vector
-     */
-    addToBoth(vectorOrData: Vector | any, metadata?: T, options?: {
-        forceEmbed?: boolean;
-    }): Promise<string>;
     /**
      * Add a vector to the remote server
      * @param id ID of the vector to add
@@ -601,7 +648,13 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options
      * @returns Array of IDs for the added items
      */
-    addBatch(items: Array<{
+    /**
+     * Add multiple nouns in batch
+     * @param items Array of nouns to add
+     * @param options Batch processing options
+     * @returns Array of generated IDs
+     */
+    addNouns(items: Array<{
         vectorOrData: Vector | any;
         metadata?: T;
     }>, options?: {
@@ -639,6 +692,14 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options
      * @returns Array of search results
      */
+    /**
+     * @deprecated Use search() with nounTypes option instead
+     * @example
+     * // Old way (deprecated)
+     * await brain.searchByNounTypes(query, 10, ['type1', 'type2'])
+     * // New way
+     * await brain.search(query, { limit: 10, nounTypes: ['type1', 'type2'] })
+     */
     searchByNounTypes(queryVectorOrData: Vector | any, k?: number, nounTypes?: string[] | null, options?: {
         forceEmbed?: boolean;
         service?: string;
@@ -652,24 +713,70 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options
      * @returns Array of search results
      */
-    search(queryVectorOrData: Vector | any, k?: number, options?: {
-        forceEmbed?: boolean;
+    /**
+     * 🔍 SIMPLE VECTOR SEARCH - Clean wrapper around find() for pure vector search
+     *
+     * @param queryVectorOrData Vector or text to search for
+     * @param k Number of results to return
+     * @param options Simple search options (metadata filters only)
+     * @returns Vector search results
+     */
+    /**
+     * 🔍 Simple Vector Similarity Search - Clean wrapper around find()
+     *
+     * search(query) = find({like: query}) - Pure vector similarity search
+     *
+     * @param queryVectorOrData - Query string, vector, or object to search with
+     * @param options - Search options for filtering and pagination
+     * @returns Array of search results with scores and metadata
+     *
+     * @example
+     * // Simple vector search
+     * await brain.search('machine learning')
+     *
+     * // With filters and pagination
+     * await brain.search('AI', {
+     *   limit: 20,
+     *   metadata: { type: 'article' },
+     *   nounTypes: ['document']
+     * })
+     */
+    search(queryVectorOrData: Vector | any, options?: {
+        limit?: number;
+        offset?: number;
+        cursor?: string;
+        metadata?: any;
         nounTypes?: string[];
-        includeVerbs?: boolean;
-        searchMode?: 'local' | 'remote' | 'combined';
-        searchVerbs?: boolean;
-        verbTypes?: string[];
-        searchConnectedNouns?: boolean;
-        verbDirection?: 'outgoing' | 'incoming' | 'both';
-        service?: string;
-        searchField?: string;
-        filter?: {
-            domain?: string;
-        };
+        itemIds?: string[];
+        excludeDeleted?: boolean;
+        threshold?: number;
+        timeout?: number;
+    }): Promise<SearchResult<T>[]>;
+    /**
+     * Helper method to encode cursor for pagination
+     * @internal
+     */
+    private encodeCursor;
+    /**
+     * Helper method to decode cursor for pagination
+     * @internal
+     */
+    private decodeCursor;
+    /**
+     * Internal method for direct HNSW vector search
+     * Used by TripleIntelligence to avoid circular dependencies
+     * Note: For pure metadata filtering, use metadataIndex.getIdsForFilter() directly - it's O(log n)!
+     * This method is for vector similarity search with optional metadata filtering during search
+     * @internal
+     */
+    _internalVectorSearch(queryVectorOrData: Vector | any, k?: number, options?: {
         metadata?: any;
-        offset?: number;
-        skipCache?: boolean;
     }): Promise<SearchResult<T>[]>;
+    /**
+     * 🎯 LEGACY: Original search implementation (kept for complex cases)
+     * This is the original search method, now used as fallback for edge cases
+     */
+    private _legacySearch;
     /**
      * Search with cursor-based pagination for better performance on large datasets
      * @param queryVectorOrData Query vector or data to search for
@@ -677,6 +784,14 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options including cursor for pagination
      * @returns Paginated search results with cursor for next page
      */
+    /**
+     * @deprecated Use search() with cursor option instead
+     * @example
+     * // Old way (deprecated)
+     * await brain.searchWithCursor(query, 10, { cursor: 'abc123' })
+     * // New way
+     * await brain.search(query, { limit: 10, cursor: 'abc123' })
+     */
     searchWithCursor(queryVectorOrData: Vector | any, k?: number, options?: {
         forceEmbed?: boolean;
         nounTypes?: string[];
@@ -726,89 +841,85 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
     /**
      * Get a vector by ID
      */
-    get(id: string): Promise<VectorDocument<T> | null>;
     /**
      * Check if a document with the given ID exists
      * This is a direct storage operation that works in write-only mode when allowDirectReads is enabled
      * @param id The ID to check for existence
      * @returns Promise<boolean> True if the document exists, false otherwise
      */
-    has(id: string): Promise<boolean>;
+    private has;
     /**
      * Check if a document with the given ID exists (alias for has)
      * This is a direct storage operation that works in write-only mode when allowDirectReads is enabled
      * @param id The ID to check for existence
      * @returns Promise<boolean> True if the document exists, false otherwise
      */
-    exists(id: string): Promise<boolean>;
+    /**
+     * Check if a noun exists
+     * @param id The noun ID
+     * @returns True if exists
+     */
+    hasNoun(id: string): Promise<boolean>;
     /**
      * Get metadata for a document by ID
      * This is a direct storage operation that works in write-only mode when allowDirectReads is enabled
      * @param id The ID of the document
      * @returns Promise<T | null> The metadata object or null if not found
      */
-    getMetadata(id: string): Promise<T | null>;
     /**
      * Get multiple documents by their IDs
      * This is a direct storage operation that works in write-only mode when allowDirectReads is enabled
      * @param ids Array of IDs to retrieve
      * @returns Promise<Array<VectorDocument<T> | null>> Array of documents (null for missing IDs)
      */
-    getBatch(ids: string[]): Promise<Array<VectorDocument<T> | null>>;
     /**
-     * Get nouns with pagination and filtering
-     * @param options Pagination and filtering options
-     * @returns Paginated result of vector documents
-     */
-    getNouns(options?: {
+     * Get multiple nouns - by IDs, filters, or pagination
+     * @param idsOrOptions Array of IDs or query options
+     * @returns Array of noun documents
+     *
+     * @example
+     * // Get by IDs
+     * await brain.getNouns(['id1', 'id2'])
+     *
+     * // Get with filters
+     * await brain.getNouns({
+     *   filter: { type: 'article' },
+     *   limit: 10
+     * })
+     *
+     * // Get with pagination
+     * await brain.getNouns({
+     *   offset: 20,
+     *   limit: 10
+     * })
+     */
+    getNouns(idsOrOptions?: string[] | {
+        ids?: string[];
+        filter?: {
+            nounType?: string | string[];
+            metadata?: Record<string, any>;
+        };
         pagination?: {
             offset?: number;
             limit?: number;
             cursor?: string;
         };
-        filter?: {
-            nounType?: string | string[];
-            service?: string | string[];
-            metadata?: Record<string, any>;
-        };
-    }): Promise<{
-        items: VectorDocument<T>[];
-        totalCount?: number;
-        hasMore: boolean;
-        nextCursor?: string;
-    }>;
-    /**
-     * Delete a vector by ID
-     * @param id The ID of the vector to delete
-     * @param options Additional options
-     * @returns Promise that resolves to true if the vector was deleted, false otherwise
-     */
-    delete(id: string, options?: {
-        service?: string;
-        hard?: boolean;
-        cascade?: boolean;
-        force?: boolean;
-    }): Promise<boolean>;
+        offset?: number;
+        limit?: number;
+    }): Promise<Array<VectorDocument<T> | null>>;
     /**
-     * Update metadata for a vector
-     * @param id The ID of the vector to update metadata for
-     * @param metadata The new metadata
-     * @param options Additional options
-     * @returns Promise that resolves to true if the metadata was updated, false otherwise
+     * Internal: Get nouns by IDs
      */
-    updateMetadata(id: string, metadata: T, options?: {
-        service?: string;
-    }): Promise<boolean>;
+    private getNounsByIds;
     /**
-     * Create a relationship between two entities
-     * This is a convenience wrapper around addVerb
+     * Get nouns with pagination and filtering
+     * @param options Pagination and filtering options
+     * @returns Paginated result of vector documents
      */
-    relate(sourceId: string, targetId: string, relationType: string, metadata?: any): Promise<string>;
     /**
-     * Create a connection between two entities
-     * This is an alias for relate() for backward compatibility
+     * Internal: Query nouns with filtering and pagination
      */
-    connect(sourceId: string, targetId: string, relationType: string, metadata?: any): Promise<string>;
+    private queryNounsByFilter;
     /**
      * Add a verb between two nouns
      * If metadata is provided and vector is not, the metadata will be vectorized using the embedding function
@@ -904,13 +1015,27 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options
      * @returns Promise that resolves to true if the verb was deleted, false otherwise
      */
+    /**
+     * Add multiple verbs (relationships) in batch
+     * @param verbs Array of verbs to add
+     * @returns Array of generated verb IDs
+     */
+    addVerbs(verbs: Array<{
+        source: string;
+        target: string;
+        type: string;
+        metadata?: any;
+    }>): Promise<string[]>;
+    /**
+     * Delete multiple verbs by IDs
+     * @param ids Array of verb IDs
+     * @returns Array of success booleans
+     */
+    deleteVerbs(ids: string[]): Promise<boolean[]>;
     deleteVerb(id: string, options?: {
         service?: string;
+        hard?: boolean;
     }): Promise<boolean>;
-    /**
-     * Clear the database
-     */
-    clear(): Promise<void>;
     /**
      * Get the number of vectors in the database
      */
@@ -920,16 +1045,8 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @returns Cache statistics including hit rate and memory usage
      */
     getCacheStats(): {
-        search: {
-            hits: number;
-            misses: number;
-            evictions: number;
-            hitRate: number;
-            size: number;
-            maxSize: number;
-            enabled: boolean;
-        };
-        searchMemoryUsage: number;
+        search: any;
+        searchMemoryUsage: any;
     };
     /**
      * Clear search cache manually (useful for testing or memory management)
@@ -1114,6 +1231,14 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options
      * @returns Array of search results
      */
+    /**
+     * @deprecated Use search() with itemIds option instead
+     * @example
+     * // Old way (deprecated)
+     * await brain.searchWithinItems(query, itemIds, 10)
+     * // New way
+     * await brain.search(query, { limit: 10, itemIds })
+     */
     searchWithinItems(queryVectorOrData: Vector | any, itemIds: string[], k?: number, options?: {
         forceEmbed?: boolean;
     }): Promise<SearchResult<T>[]>;
@@ -1126,6 +1251,14 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Additional options
      * @returns Array of search results
      */
+    /**
+     * @deprecated Use search() directly with text - it auto-detects strings
+     * @example
+     * // Old way (deprecated)
+     * await brain.searchText('query text', 10)
+     * // New way
+     * await brain.search('query text', { limit: 10 })
+     */
     searchText(query: string, k?: number, options?: {
         nounTypes?: string[];
         includeVerbs?: boolean;
@@ -1371,7 +1504,15 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param metadata Additional metadata
      * @returns Created noun ID
      */
-    addNoun(data: any, nounType: NounType, metadata?: any): Promise<string>;
+    /**
+     * Add a noun to the database
+     * Clean 2.0 API - primary method for adding data
+     *
+     * @param vectorOrData Vector array or data to embed
+     * @param metadata Metadata to store with the noun
+     * @returns The generated ID
+     */
+    addNoun(vectorOrData: Vector | any, metadata?: T): Promise<string>;
     /**
      * Add Verb - Unified relationship creation between nouns
      * Creates typed relationships with proper vector embeddings from metadata
@@ -1425,11 +1566,6 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @param options Update options
      * @returns Success boolean
      */
-    update(id: string, data?: any, metadata?: any, options?: {
-        merge?: boolean;
-        reindex?: boolean;
-        cascade?: boolean;
-    }): Promise<boolean>;
     /**
      * Preload Transformer Model - Essential for container deployments
      * Downloads and caches models during initialization to avoid runtime delays
@@ -1483,21 +1619,119 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      */
     rebuildMetadataIndex(): Promise<void>;
     /**
-     * UNIFIED API METHOD #9: Augment - Register new augmentations
+     * Get a noun by ID
+     * @param id The noun ID
+     * @returns The noun document or null
+     */
+    getNoun(id: string): Promise<VectorDocument<T> | null>;
+    /**
+     * Delete a noun by ID
+     * @param id The noun ID
+     * @returns Success boolean
+     */
+    deleteNoun(id: string): Promise<boolean>;
+    /**
+     * Delete multiple nouns by IDs
+     * @param ids Array of noun IDs
+     * @returns Array of success booleans
+     */
+    deleteNouns(ids: string[]): Promise<boolean[]>;
+    /**
+     * Update a noun
+     * @param id The noun ID
+     * @param data Optional new vector/data
+     * @param metadata Optional new metadata
+     * @returns The updated noun
+     */
+    updateNoun(id: string, data?: any, metadata?: T): Promise<VectorDocument<T>>;
+    /**
+     * Update only the metadata of a noun
+     * @param id The noun ID
+     * @param metadata New metadata
+     */
+    updateNounMetadata(id: string, metadata: T): Promise<void>;
+    /**
+     * Get metadata for a noun
+     * @param id The noun ID
+     * @returns Metadata or null
+     */
+    getNounMetadata(id: string): Promise<T | null>;
+    /**
+     * Neural API - Unified Semantic Intelligence
+     * Best-of-both: Complete functionality + Enterprise performance
+     *
+     * User-friendly methods:
+     * - brain.neural.similar() - Smart similarity detection
+     * - brain.neural.hierarchy() - Semantic hierarchy building
+     * - brain.neural.neighbors() - Neighbor graph generation
+     * - brain.neural.clusters() - Auto-detects best clustering algorithm
+     * - brain.neural.visualize() - Rich visualization data
+     * - brain.neural.outliers() - Outlier detection
+     * - brain.neural.semanticPath() - Path finding
+     *
+     * Enterprise performance methods:
+     * - brain.neural.clusterFast() - O(n) HNSW-based clustering
+     * - brain.neural.clusterLarge() - Million-item clustering
+     * - brain.neural.clusterStream() - Progressive streaming
+     * - brain.neural.getLOD() - Level-of-detail for scale
+     */
+    get neural(): any;
+    /**
+     * Simple similarity check (shorthand for neural.similar)
+     */
+    similar(a: any, b: any): Promise<number>;
+    /**
+     * Get semantic clusters (shorthand for neural.clusters)
+     */
+    clusters(options?: any): Promise<any[]>;
+    /**
+     * Get related items (shorthand for neural.neighbors)
+     */
+    related(id: string, limit?: number): Promise<any[]>;
+    /**
+     * Get visualization data (shorthand for neural.visualize)
+     */
+    visualize(options?: any): Promise<any>;
+    /**
+     * 🚀 TRIPLE INTELLIGENCE SEARCH - Natural Language & Complex Queries
+     * The revolutionary search that combines vector, graph, and metadata intelligence!
      *
-     * For registration: brain.augment(new MyAugmentation())
-     * For management: Use brain.augmentations.enable(), .disable(), .list() etc.
+     * @param query - Natural language string or structured TripleQuery
+     * @param options - Pagination and performance options
+     * @returns Unified search results with fusion scoring
      *
-     * @param action The augmentation to register OR legacy string command
-     * @param options Legacy options for string commands (deprecated)
-     * @returns this for chaining when registering, various for legacy commands
+     * @example
+     * // Natural language query
+     * await brain.find('frameworks from recent years with high popularity')
      *
-     * @deprecated String-based commands are deprecated. Use brain.augmentations.* instead
+     * // Structured query with pagination
+     * await brain.find({
+     *   like: 'machine learning',
+     *   where: { year: { greaterThan: 2020 } },
+     *   connected: { from: 'authorId123' }
+     * }, {
+     *   limit: 50,
+     *   cursor: lastCursor
+     * })
+     */
+    find(query: TripleQuery | string, options?: {
+        limit?: number;
+        offset?: number;
+        cursor?: string;
+        mode?: 'auto' | 'vector' | 'graph' | 'metadata' | 'fusion';
+        maxDepth?: number;
+        parallel?: boolean;
+        timeout?: number;
+        excludeDeleted?: boolean;
+    }): Promise<TripleResult[]>;
+    /**
+     * 🧠 NATURAL LANGUAGE PROCESSING - Auto-breakdown using all Brainy features
+     * Uses embedding model, neural tools, entity registry, and taxonomy matching
+     */
+    private processNaturalLanguage;
+    /**
+     * LEGACY: Augment method temporarily disabled during new augmentation system implementation
      */
-    augment(action: IAugmentation | 'list' | 'enable' | 'disable' | 'unregister' | 'enable-type' | 'disable-type', options?: string | {
-        name?: string;
-        type?: string;
-    }): this | any;
     /**
      * UNIFIED API METHOD #9: Export - Extract your data in various formats
      * Export your brain's knowledge for backup, migration, or integration
@@ -1580,5 +1814,45 @@ export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
      * @returns Number of augmentations disabled
      */
     disableAugmentationType(type: 'sense' | 'conduit' | 'cognition' | 'memory' | 'perception' | 'dialog' | 'activation' | 'webSocket'): number;
+    /**
+     * Clear only nouns from the database
+     * @param options Clear options requiring force confirmation
+     */
+    /**
+     * Clear all nouns from the database
+     * @param options Options including force flag to skip confirmation
+     */
+    clearNouns(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Clear only verbs from the database
+     * @param options Clear options requiring force confirmation
+     */
+    /**
+     * Clear all verbs from the database
+     * @param options Options including force flag to skip confirmation
+     */
+    clearVerbs(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Clear all data from the database (nouns and verbs)
+     * @param options Clear options requiring force confirmation
+     */
+    /**
+     * Clear all data from the database
+     * @param options Options including force flag to skip confirmation
+     */
+    clear(options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Clear all data from the database (alias for clear)
+     * @param options Options including force flag to skip confirmation
+     */
+    clearAll(options?: {
+        force?: boolean;
+    }): Promise<void>;
 }
 export { euclideanDistance, cosineDistance, manhattanDistance, dotProductDistance } from './utils/index.js';