brainy/.recovery-workspace/dist-backup-20250910-141917/brainyData.d.ts

/**
 * BrainyData
 * Main class that provides the vector database functionality
 */
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 { MetadataIndexConfig } from './utils/metadataIndex.js';
import { CleanupConfig } from './utils/periodicCleanup.js';
import { NounType, VerbType } from './types/graphTypes.js';
import { BrainyDataInterface } from './types/brainyDataInterface.js';
import { DistributedConfig } from './types/distributedTypes.js';
import { SearchCacheConfig } from './utils/searchCache.js';
import { ImprovedNeuralAPI } from './neural/improvedNeuralAPI.js';
import { TripleQuery, TripleResult } from './triple/TripleIntelligence.js';
export interface BrainyDataConfig {
    /**
     * HNSW index configuration
     * Uses the optimized HNSW implementation which supports large datasets
     * through product quantization and disk-based storage
     */
    hnsw?: Partial<HNSWOptimizedConfig>;
    /**
     * Default service name to use for all operations
     * When specified, this service name will be used for all operations
     * that don't explicitly provide a service name
     */
    defaultService?: string;
    /**
     * Distance function to use for similarity calculations
     */
    distanceFunction?: DistanceFunction;
    /**
     * Custom storage adapter (if not provided, will use OPFS or memory storage)
     */
    storageAdapter?: StorageAdapter;
    /**
     * Storage configuration options
     * These will be passed to createStorage if storageAdapter is not provided
     */
    storage?: {
        requestPersistentStorage?: boolean;
        r2Storage?: {
            bucketName?: string;
            accountId?: string;
            accessKeyId?: string;
            secretAccessKey?: string;
        };
        s3Storage?: {
            bucketName?: string;
            accessKeyId?: string;
            secretAccessKey?: string;
            region?: string;
        };
        gcsStorage?: {
            bucketName?: string;
            accessKeyId?: string;
            secretAccessKey?: string;
            endpoint?: string;
        };
        customS3Storage?: {
            bucketName?: string;
            accessKeyId?: string;
            secretAccessKey?: string;
            endpoint?: string;
            region?: string;
        };
        forceFileSystemStorage?: boolean;
        forceMemoryStorage?: boolean;
        cacheConfig?: {
            hotCacheMaxSize?: number;
            hotCacheEvictionThreshold?: number;
            warmCacheTTL?: number;
            batchSize?: number;
            autoTune?: boolean;
            autoTuneInterval?: number;
            readOnly?: boolean;
        };
    };
    /**
     * Embedding function to convert data to vectors
     */
    embeddingFunction?: EmbeddingFunction;
    /**
     * Set the database to read-only mode
     * When true, all write operations will throw an error
     * Note: Statistics and index optimizations are still allowed unless frozen is also true
     */
    readOnly?: boolean;
    /**
     * Completely freeze the database, preventing all changes including statistics and index optimizations
     * When true, the database is completely immutable (no data changes, no index rebalancing, no statistics updates)
     * This is useful for forensic analysis, testing with deterministic state, or compliance scenarios
     * Default: false (allows optimizations even in readOnly mode)
     */
    frozen?: boolean;
    /**
     * Enable lazy loading in read-only mode
     * When true and in read-only mode, the index is not fully loaded during initialization
     * Nodes are loaded on-demand during search operations
     * This improves startup performance for large datasets
     */
    lazyLoadInReadOnlyMode?: boolean;
    /**
     * Set the database to write-only mode
     * When true, the index is not loaded into memory and search operations will throw an error
     * This is useful for data ingestion scenarios where only write operations are needed
     */
    writeOnly?: boolean;
    /**
     * Allow direct storage reads in write-only mode
     * When true and writeOnly is also true, enables direct ID-based lookups (get, has, exists, getMetadata, getBatch, getVerb)
     * that don't require search indexes. Search operations (search, similar, query, findRelated) remain disabled.
     * This is useful for writer services that need deduplication without loading expensive search indexes.
     */
    allowDirectReads?: boolean;
    /**
     * Remote server configuration for search operations
     */
    remoteServer?: {
        /**
         * WebSocket URL of the remote Brainy server
         */
        url: string;
        /**
         * WebSocket protocols to use for the connection
         */
        protocols?: string | string[];
        /**
         * Whether to automatically connect to the remote server on initialization
         */
        autoConnect?: boolean;
    };
    /**
     * Logging configuration
     */
    logging?: {
        /**
         * Whether to enable verbose logging
         * When false, suppresses non-essential log messages like model loading progress
         * Default: true
         */
        verbose?: boolean;
    };
    /**
     * Metadata indexing configuration
     */
    metadataIndex?: MetadataIndexConfig;
    /**
     * Search result caching configuration
     * Improves performance for repeated queries
     */
    searchCache?: SearchCacheConfig;
    /**
     * Timeout configuration for async operations
     * Controls how long operations wait before timing out
     */
    timeouts?: {
        /**
         * Timeout for get operations in milliseconds
         * Default: 30000 (30 seconds)
         */
        get?: number;
        /**
         * Timeout for add operations in milliseconds
         * Default: 60000 (60 seconds)
         */
        add?: number;
        /**
         * Timeout for delete operations in milliseconds
         * Default: 30000 (30 seconds)
         */
        delete?: number;
    };
    /**
     * Retry policy configuration for failed operations
     * Controls how operations are retried on failure
     */
    retryPolicy?: {
        /**
         * Maximum number of retry attempts
         * Default: 3
         */
        maxRetries?: number;
        /**
         * Initial delay between retries in milliseconds
         * Default: 1000 (1 second)
         */
        initialDelay?: number;
        /**
         * Maximum delay between retries in milliseconds
         * Default: 10000 (10 seconds)
         */
        maxDelay?: number;
        /**
         * Multiplier for exponential backoff
         * Default: 2
         */
        backoffMultiplier?: number;
    };
    /**
     * Real-time update configuration
     * Controls how the database handles updates when data is added by external processes
     */
    realtimeUpdates?: {
        /**
         * Whether to enable automatic updates of the index and statistics
         * When true, the database will periodically check for new data in storage
         * Default: false
         */
        enabled?: boolean;
        /**
         * The interval (in milliseconds) at which to check for updates
         * Default: 30000 (30 seconds)
         */
        interval?: number;
        /**
         * Whether to update statistics when checking for updates
         * Default: true
         */
        updateStatistics?: boolean;
        /**
         * Whether to update the index when checking for updates
         * Default: true
         */
        updateIndex?: boolean;
    };
    /**
     * Distributed mode configuration
     * Enables coordination across multiple Brainy instances
     */
    distributed?: DistributedConfig | boolean;
    /**
     * Cache configuration for optimizing search performance
     * Controls how the system caches data for faster access
     * Particularly important for large datasets in S3 or other remote storage
     */
    cache?: {
        /**
         * Whether to enable auto-tuning of cache parameters
         * When true, the system will automatically adjust cache sizes based on usage patterns
         * Default: true
         */
        autoTune?: boolean;
        /**
         * The interval (in milliseconds) at which to auto-tune cache parameters
         * Only applies when autoTune is true
         * Default: 60000 (60 seconds)
         */
        autoTuneInterval?: number;
        /**
         * Maximum size of the hot cache (most frequently accessed items)
         * If provided, overrides the automatically detected optimal size
         * For large datasets, consider values between 5000-50000 depending on available memory
         */
        hotCacheMaxSize?: number;
        /**
         * Threshold at which to start evicting items from the hot cache
         * Expressed as a fraction of hotCacheMaxSize (0.0 to 1.0)
         * Default: 0.8 (start evicting when cache is 80% full)
         */
        hotCacheEvictionThreshold?: number;
        /**
         * Time-to-live for items in the warm cache in milliseconds
         * Default: 3600000 (1 hour)
         */
        warmCacheTTL?: number;
        /**
         * Batch size for operations like prefetching
         * Larger values improve throughput but use more memory
         * For S3 or remote storage with large datasets, consider values between 50-200
         */
        batchSize?: number;
        /**
         * Read-only mode specific optimizations
         * These settings are only applied when readOnly is true
         */
        readOnlyMode?: {
            /**
             * Maximum size of the hot cache in read-only mode
             * In read-only mode, larger cache sizes can be used since there are no write operations
             * For large datasets, consider values between 10000-100000 depending on available memory
             */
            hotCacheMaxSize?: number;
            /**
             * Batch size for operations in read-only mode
             * Larger values improve throughput in read-only mode
             * For S3 or remote storage with large datasets, consider values between 100-300
             */
            batchSize?: number;
            /**
             * Prefetch strategy for read-only mode
             * Controls how aggressively the system prefetches data
             * Options: 'conservative', 'moderate', 'aggressive'
             * Default: 'moderate'
             */
            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
     * Enabled by default for better relationship quality
     */
    intelligentVerbScoring?: {
        /**
         * Whether to enable intelligent verb scoring
         * Default: true (enabled by default for better relationship quality)
         */
        enabled?: boolean;
        /**
         * Enable semantic proximity scoring based on entity embeddings
         * Default: true
         */
        enableSemanticScoring?: boolean;
        /**
         * Enable frequency-based weight amplification
         * Default: true
         */
        enableFrequencyAmplification?: boolean;
        /**
         * Enable temporal decay for weights
         * Default: true
         */
        enableTemporalDecay?: boolean;
        /**
         * Decay rate per day for temporal scoring (0-1)
         * Default: 0.01 (1% decay per day)
         */
        temporalDecayRate?: number;
        /**
         * Minimum weight threshold
         * Default: 0.1
         */
        minWeight?: number;
        /**
         * Maximum weight threshold
         * Default: 1.0
         */
        maxWeight?: number;
        /**
         * Base confidence score for new relationships
         * Default: 0.5
         */
        baseConfidence?: number;
        /**
         * Learning rate for adaptive scoring (0-1)
         * Default: 0.1
         */
        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;
    /**
     * Periodic cleanup configuration for old soft-deleted items
     * Automatically removes soft-deleted items after a specified age to prevent memory buildup
     * Default: enabled with 1 hour max age and 15 minute cleanup interval
     */
    cleanup?: Partial<CleanupConfig>;
}
export declare class BrainyData<T = any> implements BrainyDataInterface<T> {
    hnswIndex: HNSWIndex | HNSWIndexOptimized;
    private storage;
    private isInitialized;
    private isInitializing;
    private embeddingFunction;
    private distanceFunction;
    private requestPersistentStorage;
    private readOnly;
    private frozen;
    private lazyLoadInReadOnlyMode;
    private writeOnly;
    private allowDirectReads;
    private storageConfig;
    private config;
    private rawConfig;
    private useOptimizedIndex;
    private _dimensions;
    private loggingConfig;
    private defaultService;
    /**
     * Enterprise augmentation system
     * Handles WAL, connection pooling, batching, streaming, and intelligent scoring
     */
    private augmentations;
    /**
     * Neural similarity API for semantic operations
     */
    private _neural?;
    private _tripleEngine?;
    private _nlpProcessor?;
    private _importManager?;
    private cacheAutoConfigurator;
    private periodicCleanup;
    private timeoutConfig;
    private retryConfig;
    private cacheConfig;
    private realtimeUpdateConfig;
    private updateTimerId;
    private maintenanceIntervals;
    private lastUpdateTime;
    private lastKnownNounCount;
    private remoteServerConfig;
    private intelligentVerbScoring;
    private distributedConfig;
    private configManager;
    private partitioner;
    private operationalMode;
    private domainDetector;
    private networkTransport;
    private coordinator;
    private shardManager;
    private cacheSync;
    private readWriteSeparation;
    private httpTransport;
    private storageDiscovery;
    private queryPlanner;
    private shardMigrationManager;
    private get cache();
    private get index();
    private get metadataIndex();
    private get metrics();
    private get monitoring();
    /**
     * Get the vector dimensions
     */
    get dimensions(): number;
    /**
     * Get the maximum connections parameter from HNSW configuration
     */
    get maxConnections(): number;
    /**
     * Get the efConstruction parameter from HNSW configuration
     */
    get efConstruction(): number;
    /**
     * Check if BrainyData has been initialized
     */
    get initialized(): boolean;
    /**
     * Create a new vector database
     * @param config - Zero-config string ('production', 'development', 'minimal'),
     *                 simplified config object, or legacy full config
     */
    constructor(config?: BrainyDataConfig | string | any);
    /**
     * 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;
    /**
     * Initialize periodic cleanup system for old soft-deleted items
     * SAFETY-CRITICAL: Coordinates with both HNSW and metadata indexes
     */
    private initializePeriodicCleanup;
    private checkReadOnly;
    /**
     * Check if the database is frozen and throw an error if it is
     * @throws Error if the database is frozen
     */
    private checkFrozen;
    /**
     * Check if the database is in write-only mode and throw an error if it is
     * @param allowExistenceChecks If true, allows existence checks (get operations) in write-only mode
     * @param isDirectStorageOperation If true, allows the operation when allowDirectReads is enabled
     * @throws Error if the database is in write-only mode and operation is not allowed
     */
    private checkWriteOnly;
    /**
     * Start real-time updates if enabled in the configuration
     * This will periodically check for new data in storage and update the in-memory index and statistics
     */
    private startRealtimeUpdates;
    /**
     * Stop real-time updates
     */
    private stopRealtimeUpdates;
    /**
     * Manually check for updates in storage and update the in-memory index and statistics
     * This can be called by the user to force an update check even if automatic updates are not enabled
     */
    checkForUpdatesNow(): Promise<void>;
    /**
     * Enable real-time updates with the specified configuration
     * @param config Configuration for real-time updates
     */
    enableRealtimeUpdates(config?: Partial<BrainyDataConfig['realtimeUpdates']>): void;
    /**
     * Start metadata index maintenance
     */
    private startMetadataIndexMaintenance;
    /**
     * Disable real-time updates
     */
    disableRealtimeUpdates(): void;
    /**
     * Get the current real-time update configuration
     * @returns The current real-time update configuration
     */
    getRealtimeUpdateConfig(): Required<NonNullable<BrainyDataConfig['realtimeUpdates']>>;
    /**
     * Check for updates in storage and update the in-memory index and statistics if needed
     * This is called periodically by the update timer when real-time updates are enabled
     * Uses change log mechanism for efficient updates instead of full scans
     */
    private checkForUpdates;
    /**
     * Apply changes using the change log mechanism (efficient for distributed storage)
     */
    private applyChangesFromLog;
    /**
     * Apply changes using full scan method (fallback for storage adapters without change log support)
     */
    private applyChangesFromFullScan;
    /**
     * Provide feedback to the intelligent verb scoring system for learning
     * This allows the system to learn from user corrections or validation
     *
     * @param sourceId - Source entity ID
     * @param targetId - Target entity ID
     * @param verbType - Relationship type
     * @param feedbackWeight - The corrected/validated weight (0-1)
     * @param feedbackConfidence - The corrected/validated confidence (0-1)
     * @param feedbackType - Type of feedback ('correction', 'validation', 'enhancement')
     */
    provideFeedbackForVerbScoring(sourceId: string, targetId: string, verbType: string, feedbackWeight: number, feedbackConfidence?: number, feedbackType?: 'correction' | 'validation' | 'enhancement'): Promise<void>;
    /**
     * Get learning statistics from the intelligent verb scoring system
     */
    getVerbScoringStats(): any;
    /**
     * Export learning data from the intelligent verb scoring system
     */
    exportVerbScoringLearningData(): string | null;
    /**
     * Import learning data into the intelligent verb scoring system
     */
    importVerbScoringLearningData(jsonData: string): void;
    /**
     * Get the current augmentation name if available
     * This is used to auto-detect the service performing data operations
     * @returns The name of the current augmentation or 'default' if none is detected
     */
    private getCurrentAugmentation;
    /**
     * Get the service name from options or fallback to default service
     * This provides a consistent way to handle service names across all methods
     * @param options Options object that may contain a service property
     * @returns The service name to use for operations
     */
    private getServiceName;
    /**
     * Initialize the database
     * Loads existing data from storage if available
     */
    init(): Promise<void>;
    /**
     * Initialize distributed mode
     * Sets up configuration management, partitioning, and operational modes
     */
    private initializeDistributedMode;
    /**
     * Handle distributed configuration updates
     */
    private handleDistributedConfigUpdate;
    /**
     * Initialize NEW distributed components for Brainy 3.0
     * This enables true multi-node operation with consensus and sharding
     */
    private initializeDistributedComponents;
    /**
     * Execute a query on local shards
     */
    private executeLocalQuery;
    /**
     * Set up distributed operation handlers
     */
    private setupDistributedOperations;
    /**
     * Local add operation (without distribution)
     */
    private localAdd;
    /**
     * Local find operation (potentially for a specific shard)
     */
    private localFind;
    /**
     * Get distributed health status
     * @returns Health status if distributed mode is enabled
     */
    getHealthStatus(): any;
    /**
     * Add multiple vectors or data items to the database
     * @param items Array of items to add
     * @param options Additional options
     * @returns Array of IDs for the added items
     */
    /**
     * Add multiple nouns in batch with required types
     * @param items Array of nouns to add (all must have types)
     * @param options Batch processing options
     * @returns Array of generated IDs
     */
    addNouns(items: Array<{
        vectorOrData: Vector | any;
        nounType: NounType | string;
        metadata?: T;
    }>, options?: {
        forceEmbed?: boolean;
        addToRemote?: boolean;
        concurrency?: number;
        batchSize?: number;
    }): Promise<string[]>;
    /**
     * Filter search results by service
     * @param results Search results to filter
     * @param service Service to filter by
     * @returns Filtered search results
     * @private
     */
    private filterResultsByService;
    /**
     * Search for similar vectors within specific noun types
     * @param queryVectorOrData Query vector or data to search for
     * @param k Number of results to return
     * @param nounTypes Array of noun types to search within, or null to search all
     * @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;
        metadata?: any;
        offset?: number;
    }): Promise<SearchResult<T>[]>;
    /**
     * Search for similar vectors
     * @param queryVectorOrData Query vector or data to search for
     * @param k Number of results to return
     * @param options Additional options
     * @returns Array of search results
     */
    /**
     * 🔍 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[];
        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;
    }): 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
     * @param k Number of results to return
     * @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[];
        includeVerbs?: boolean;
        service?: string;
        searchField?: string;
        filter?: {
            domain?: string;
        };
        cursor?: SearchCursor;
        skipCache?: boolean;
    }): Promise<PaginatedSearchResult<T>>;
    /**
     * Search the local database for similar vectors
     * @param queryVectorOrData Query vector or data to search for
     * @param k Number of results to return
     * @param options Additional options
     * @returns Array of search results
     */
    searchLocal(queryVectorOrData: Vector | any, k?: number, options?: {
        forceEmbed?: boolean;
        nounTypes?: string[];
        includeVerbs?: boolean;
        service?: string;
        searchField?: string;
        priorityFields?: string[];
        filter?: {
            domain?: string;
        };
        metadata?: any;
        offset?: number;
        skipCache?: boolean;
    }): Promise<SearchResult<T>[]>;
    /**
     * Find entities similar to a given entity ID
     * @param id ID of the entity to find similar entities for
     * @param options Additional options
     * @returns Array of search results with similarity scores
     */
    findSimilar(id: string, options?: {
        limit?: number;
        nounTypes?: string[];
        includeVerbs?: boolean;
        searchMode?: 'local' | 'remote' | 'combined';
        relationType?: string;
    }): Promise<SearchResult<T>[]>;
    /**
     * Get a vector by ID
     */
    /**
     * 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
     */
    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
     */
    /**
     * 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
     */
    /**
     * 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)
     */
    /**
     * 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;
        };
        offset?: number;
        limit?: number;
    }): Promise<Array<VectorDocument<T> | null>>;
    /**
     * Internal: Get nouns by IDs
     */
    private getNounsByIds;
    /**
     * Get nouns with pagination and filtering
     * @param options Pagination and filtering options
     * @returns Paginated result of vector documents
     */
    /**
     * Internal: Query nouns with filtering and pagination
     */
    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
     *
     * @param sourceId ID of the source noun
     * @param targetId ID of the target noun
     * @param vector Optional vector for the verb
     * @param options Additional options:
     *   - type: Type of the verb
     *   - weight: Weight of the verb
     *   - metadata: Metadata for the verb
     *   - forceEmbed: Force using the embedding function for metadata even if vector is provided
     *   - id: Optional ID to use instead of generating a new one
     *   - autoCreateMissingNouns: Automatically create missing nouns if they don't exist
     *   - missingNounMetadata: Metadata to use when auto-creating missing nouns
     *   - writeOnlyMode: Skip noun existence checks for high-speed streaming (creates placeholder nouns)
     *
     * @returns The ID of the added verb
     *
     * @throws Error if source or target nouns don't exist and autoCreateMissingNouns is false or auto-creation fails
     */
    private _addVerbInternal;
    /**
     * Get a verb by ID
     * This is a direct storage operation that works in write-only mode when allowDirectReads is enabled
     */
    getVerb(id: string): Promise<GraphVerb | null>;
    /**
     * Internal performance optimization: intelligently load verbs when beneficial
     * @internal - Used by search, indexing, and caching optimizations
     */
    private _optimizedLoadAllVerbs;
    /**
     * Internal performance optimization: intelligently load nouns when beneficial
     * @internal - Used by search, indexing, and caching optimizations
     */
    private _optimizedLoadAllNouns;
    /**
     * Intelligent decision making for when to preload all data
     * @internal
     */
    private _shouldPreloadAllData;
    /**
     * Estimate if dataset size is reasonable for in-memory loading
     * @internal
     */
    private _isDatasetSizeReasonable;
    /**
     * Get verbs with pagination and filtering
     * @param options Pagination and filtering options
     * @returns Paginated result of verbs
     */
    getVerbs(options?: {
        pagination?: {
            offset?: number;
            limit?: number;
            cursor?: string;
        };
        filter?: {
            verbType?: string | string[];
            sourceId?: string | string[];
            targetId?: string | string[];
            service?: string | string[];
            metadata?: Record<string, any>;
        };
    }): Promise<{
        items: GraphVerb[];
        totalCount?: number;
        hasMore: boolean;
        nextCursor?: string;
    }>;
    /**
     * Get verbs by source noun ID
     * @param sourceId The ID of the source noun
     * @returns Array of verbs originating from the specified source
     */
    getVerbsBySource(sourceId: string): Promise<GraphVerb[]>;
    /**
     * Get verbs by target noun ID
     * @param targetId The ID of the target noun
     * @returns Array of verbs targeting the specified noun
     */
    getVerbsByTarget(targetId: string): Promise<GraphVerb[]>;
    /**
     * Get verbs by type
     * @param type The type of verb to retrieve
     * @returns Array of verbs of the specified type
     */
    getVerbsByType(type: string): Promise<GraphVerb[]>;
    /**
     * Get all verbs associated with a specific noun (both as source and target)
     * @param nounId The ID of the noun
     * @returns Array of verbs where the noun is either source or target
     */
    getVerbsForNoun(nounId: string): Promise<GraphVerb[]>;
    /**
     * Delete a verb
     * @param id The ID of the verb to delete
     * @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;
    }): Promise<boolean>;
    /**
     * Restore a soft-deleted verb (complement to consistent soft delete)
     * @param id The verb ID to restore
     * @param options Options for the restore operation
     * @returns Promise<boolean> True if restored, false if not found or not deleted
     */
    restoreVerb(id: string, options?: {
        service?: string;
    }): Promise<boolean>;
    /**
     * Get the number of vectors in the database
     */
    size(): number;
    /**
     * Get search cache statistics for performance monitoring
     * @returns Cache statistics including hit rate and memory usage
     */
    getCacheStats(): {
        search: any;
        searchMemoryUsage: any;
    };
    /**
     * Clear search cache manually (useful for testing or memory management)
     */
    clearCache(): void;
    /**
     * Adapt cache configuration based on current performance metrics
     * This method analyzes usage patterns and automatically optimizes cache settings
     * @private
     */
    private adaptCacheConfiguration;
    /**
     * @deprecated Use add() instead - it's smart by default now
     * @hidden
     */
    /**
     * Get the number of nouns in the database (excluding verbs)
     * This is used for statistics reporting to match the expected behavior in tests
     * @private
     */
    private getNounCount;
    /**
     * Force an immediate flush of statistics to storage
     * This ensures that any pending statistics updates are written to persistent storage
     * @returns Promise that resolves when the statistics have been flushed
     */
    flushStatistics(): Promise<void>;
    /**
     * Update storage sizes if needed (called periodically for performance)
     */
    private updateStorageSizesIfNeeded;
    /**
     * Get statistics about the current state of the database
     * @param options Additional options for retrieving statistics
     * @returns Object containing counts of nouns, verbs, metadata entries, and HNSW index size
     */
    getStatistics(options?: {
        service?: string | string[];
        forceRefresh?: boolean;
    }): Promise<{
        nounCount: number;
        verbCount: number;
        metadataCount: number;
        hnswIndexSize: number;
        nouns?: {
            count: number;
        };
        verbs?: {
            count: number;
        };
        metadata?: {
            count: number;
        };
        operations?: {
            add: number;
            search: number;
            delete: number;
            update: number;
            relate: number;
            total: number;
        };
        serviceBreakdown?: {
            [service: string]: {
                nounCount: number;
                verbCount: number;
                metadataCount: number;
            };
        };
    }>;
    /**
     * List all services that have written data to the database
     * @returns Array of service statistics
     */
    listServices(): Promise<import('./coreTypes.js').ServiceStatistics[]>;
    /**
     * Get statistics for a specific service
     * @param service The service name to get statistics for
     * @returns Service statistics or null if service not found
     */
    getServiceStatistics(service: string): Promise<import('./coreTypes.js').ServiceStatistics | null>;
    /**
     * Check if the database is in read-only mode
     * @returns True if the database is in read-only mode, false otherwise
     */
    isReadOnly(): boolean;
    /**
     * Set the database to read-only mode
     * @param readOnly True to set the database to read-only mode, false to allow writes
     */
    setReadOnly(readOnly: boolean): void;
    /**
     * Check if the database is frozen (completely immutable)
     * @returns True if the database is frozen, false otherwise
     */
    isFrozen(): boolean;
    /**
     * Set the database to frozen mode (completely immutable)
     * When frozen, no changes are allowed including statistics updates and index optimizations
     * @param frozen True to freeze the database, false to allow optimizations
     */
    setFrozen(frozen: boolean): void;
    /**
     * Check if the database is in write-only mode
     * @returns True if the database is in write-only mode, false otherwise
     */
    isWriteOnly(): boolean;
    /**
     * Set the database to write-only mode
     * @param writeOnly True to set the database to write-only mode, false to allow searches
     */
    setWriteOnly(writeOnly: boolean): void;
    /**
     * Embed text or data into a vector using the same embedding function used by this instance
     * This allows clients to use the same TensorFlow Universal Sentence Encoder throughout their application
     *
     * @param data Text or data to embed
     * @returns A promise that resolves to the embedded vector
     */
    embed(data: string | string[]): Promise<Vector>;
    /**
     * Calculate similarity between two vectors or between two pieces of text/data
     * This method allows clients to directly calculate similarity scores between items
     * without needing to add them to the database
     *
     * @param a First vector or text/data to compare
     * @param b Second vector or text/data to compare
     * @param options Additional options
     * @returns A promise that resolves to the similarity score (higher means more similar)
     */
    calculateSimilarity(a: Vector | string | string[], b: Vector | string | string[], options?: {
        forceEmbed?: boolean;
        distanceFunction?: DistanceFunction;
    }): Promise<number>;
    /**
     * Search for verbs by type and/or vector similarity
     * @param queryVectorOrData Query vector or data to search for
     * @param k Number of results to return
     * @param options Additional options
     * @returns Array of verbs with similarity scores
     */
    searchVerbs(queryVectorOrData: Vector | any, k?: number, options?: {
        forceEmbed?: boolean;
        verbTypes?: string[];
        service?: string;
    }): Promise<Array<GraphVerb & {
        similarity: number;
    }>>;
    /**
     * Search for nouns connected by specific verb types
     * @param queryVectorOrData Query vector or data to search for
     * @param k Number of results to return
     * @param options Additional options
     * @returns Array of search results
     */
    searchNounsByVerbs(queryVectorOrData: Vector | any, k?: number, options?: {
        forceEmbed?: boolean;
        verbTypes?: string[];
        direction?: 'outgoing' | 'incoming' | 'both';
    }): Promise<SearchResult<T>[]>;
    /**
     * Get available filter values for a field
     * Useful for building dynamic filter UIs
     *
     * @param field The field name to get values for
     * @returns Array of available values for that field
     */
    getFilterValues(field: string): Promise<string[]>;
    /**
     * Get all available filter fields
     * Useful for discovering what metadata fields are indexed
     *
     * @returns Array of indexed field names
     */
    getFilterFields(): Promise<string[]>;
    /**
     * Search within a specific set of items
     * This is useful when you've pre-filtered items and want to search only within them
     *
     * @param queryVectorOrData Query vector or data to search for
     * @param itemIds Array of item IDs to search within
     * @param k Number of results to return
     * @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>[]>;
    /**
     * Search for similar documents using a text query
     * This is a convenience method that embeds the query text and performs a search
     *
     * @param query Text query to search for
     * @param k Number of results to return
     * @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;
        searchMode?: 'local' | 'remote' | 'combined';
        metadata?: any;
    }): Promise<SearchResult<T>[]>;
    /**
     * Ensure the database is initialized
     */
    private ensureInitialized;
    /**
     * Get information about the current storage usage and capacity
     * @returns Object containing the storage type, used space, quota, and additional details
     */
    status(): Promise<{
        type: string;
        used: number;
        quota: number | null;
        details?: Record<string, any>;
    }>;
    /**
     * Shut down the database and clean up resources
     * This should be called when the database is no longer needed
     */
    shutDown(): Promise<void>;
    /**
     * Backup all data from the database to a JSON-serializable format
     * @returns Object containing all nouns, verbs, noun types, verb types, HNSW index, and other related data
     *
     * The HNSW index data includes:
     * - entryPointId: The ID of the entry point for the graph
     * - maxLevel: The maximum level in the hierarchical structure
     * - dimension: The dimension of the vectors
     * - config: Configuration parameters for the HNSW algorithm
     * - connections: A serialized representation of the connections between nouns
     */
    backup(): Promise<{
        nouns: VectorDocument<T>[];
        verbs: GraphVerb[];
        nounTypes: string[];
        verbTypes: string[];
        version: string;
        hnswIndex?: {
            entryPointId: string | null;
            maxLevel: number;
            dimension: number | null;
            config: HNSWConfig;
            connections: Record<string, Record<string, string[]>>;
        };
    }>;
    /**
     * Import sparse data into the database
     * @param data The sparse data to import
     *             If vectors are not present for nouns, they will be created using the embedding function
     * @param options Import options
     * @returns Object containing counts of imported items
     */
    importSparseData(data: {
        nouns: VectorDocument<T>[];
        verbs: GraphVerb[];
        nounTypes?: string[];
        verbTypes?: string[];
        hnswIndex?: {
            entryPointId: string | null;
            maxLevel: number;
            dimension: number | null;
            config: HNSWConfig;
            connections: Record<string, Record<string, string[]>>;
        };
        version: string;
    }, options?: {
        clearExisting?: boolean;
    }): Promise<{
        nounsRestored: number;
        verbsRestored: number;
    }>;
    /**
     * Restore data into the database from a previously backed up format
     * @param data The data to restore, in the format returned by backup()
     *             This can include HNSW index data if it was included in the backup
     *             If vectors are not present for nouns, they will be created using the embedding function
     * @param options Restore options
     * @returns Object containing counts of restored items
     */
    restore(data: {
        nouns: VectorDocument<T>[];
        verbs: GraphVerb[];
        nounTypes?: string[];
        verbTypes?: string[];
        hnswIndex?: {
            entryPointId: string | null;
            maxLevel: number;
            dimension: number | null;
            config: HNSWConfig;
            connections: Record<string, Record<string, string[]>>;
        };
        version: string;
    }, options?: {
        clearExisting?: boolean;
    }): Promise<{
        nounsRestored: number;
        verbsRestored: number;
    }>;
    /**
     * Generate a random graph of data with typed nouns and verbs for testing and experimentation
     * @param options Configuration options for the random graph
     * @returns Object containing the IDs of the generated nouns and verbs
     */
    generateRandomGraph(options?: {
        nounCount?: number;
        verbCount?: number;
        nounTypes?: NounType[];
        verbTypes?: VerbType[];
        clearExisting?: boolean;
        seed?: string;
    }): Promise<{
        nounIds: string[];
        verbIds: string[];
    }>;
    /**
     * Get available field names by service
     * This helps users understand what fields are available for searching from different data sources
     * @returns Record of field names by service
     */
    getAvailableFieldNames(): Promise<Record<string, string[]>>;
    /**
     * Get standard field mappings
     * This helps users understand how fields from different services map to standard field names
     * @returns Record of standard field mappings
     */
    getStandardFieldMappings(): Promise<Record<string, Record<string, string[]>>>;
    /**
     * Search using a standard field name
     * This allows searching across multiple services using a standardized field name
     * @param standardField The standard field name to search in
     * @param searchTerm The term to search for
     * @param k Number of results to return
     * @param options Additional search options
     * @returns Array of search results
     */
    searchByStandardField(standardField: string, searchTerm: string, k?: number, options?: {
        services?: string[];
        includeVerbs?: boolean;
        searchMode?: 'local' | 'remote' | 'combined';
    }): Promise<SearchResult<T>[]>;
    /**
     * Cleanup distributed resources
     * Should be called when shutting down the instance
     */
    cleanup(): Promise<void>;
    /**
     * Load environment variables from Cortex configuration
     * This enables services to automatically load all their configs from Brainy
     * @returns Promise that resolves when environment is loaded
     */
    loadEnvironment(): Promise<void>;
    /**
     * Set a configuration value with optional encryption
     * @param key Configuration key
     * @param value Configuration value
     * @param options Options including encryption
     */
    setConfig(key: string, value: any, options?: {
        encrypt?: boolean;
    }): Promise<void>;
    /**
     * Get a configuration value with automatic decryption
     * @param key Configuration key
     * @param options Options including decryption (auto-detected by default)
     * @returns Configuration value or undefined
     */
    getConfig(key: string, options?: {
        decrypt?: boolean;
    }): Promise<any>;
    /**
     * Encrypt data using universal crypto utilities
     */
    encryptData(data: string): Promise<string>;
    /**
     * Decrypt data using universal crypto utilities
     */
    decryptData(encryptedData: string): Promise<string>;
    /**
     * Neural Import - Smart bulk data import with semantic type detection
     * Uses transformer embeddings to automatically detect and classify data types
     * @param data Array of data items or single item to import
     * @param options Import options including type hints and processing mode
     * @returns Array of created IDs
     */
    import(source: any[] | any | string | Buffer, options?: {
        format?: 'auto' | 'json' | 'csv' | 'yaml' | 'text';
        batchSize?: number;
        relationships?: boolean;
    }): Promise<string[]>;
    /**
     * Add Noun - Explicit noun creation with strongly-typed NounType
     * For when you know exactly what type of noun you're creating
     * @param data The noun data
     * @param nounType The explicit noun type from NounType enum
     * @param metadata Additional metadata
     * @returns Created noun ID
     */
    /**
     * Add a noun to the database with required type
     * Clean 2.0 API - primary method for adding data
     *
     * @param vectorOrData Vector array or data to embed
     * @param nounType Required noun type (one of 31 types)
     * @param metadata Optional metadata object
     * @returns The generated ID
     */
    addNoun(vectorOrData: Vector | any, nounType: NounType | string, metadata?: T, options?: {
        forceEmbed?: boolean;
        addToRemote?: boolean;
        id?: string;
        service?: string;
        process?: 'auto' | 'literal' | 'neural';
    }): Promise<string>;
    /**
     * Add Verb - Unified relationship creation between nouns
     * Creates typed relationships with proper vector embeddings from metadata
     * @param sourceId Source noun ID
     * @param targetId Target noun ID
     * @param verbType Relationship type from VerbType enum
     * @param metadata Additional metadata for the relationship (will be embedded for searchability)
     * @param weight Relationship weight/strength (0-1, default: 0.5)
     * @returns Created verb ID
     */
    addVerb(sourceId: string, targetId: string, verbType: VerbType, metadata?: any, weight?: number): Promise<string>;
    /**
     * Auto-detect whether to use neural processing for data
     * @private
     */
    private shouldAutoProcessNeurally;
    /**
     * Detect noun type using semantic analysis
     * @private
     */
    private detectNounType;
    /**
     * Get Noun with Connected Verbs - Retrieve noun and all its relationships
     * Provides complete traversal view of a noun and its connections using existing searchVerbs
     * @param nounId The noun ID to retrieve
     * @param options Traversal options
     * @returns Noun data with connected verbs and related nouns
     */
    getNounWithVerbs(nounId: string, options?: {
        includeIncoming?: boolean;
        includeOutgoing?: boolean;
        verbLimit?: number;
        verbTypes?: string[];
    }): Promise<{
        noun: {
            id: string;
            data: any;
            metadata: any;
            nounType?: NounType;
        };
        incomingVerbs: any[];
        outgoingVerbs: any[];
        totalConnections: number;
    } | null>;
    /**
     * Update - Smart noun update with automatic index synchronization
     * Updates both data and metadata while maintaining search index integrity
     * @param id The noun ID to update
     * @param data New data (optional - if not provided, only metadata is updated)
     * @param metadata New metadata (merged with existing)
     * @param options Update options
     * @returns Success boolean
     */
    /**
     * Preload Transformer Model - Essential for container deployments
     * Downloads and caches models during initialization to avoid runtime delays
     * @param options Preload options
     * @returns Success boolean and model info
     */
    static preloadModel(options?: {
        model?: string;
        cacheDir?: string;
        device?: string;
        force?: boolean;
    }): Promise<{
        success: boolean;
        modelPath: string;
        modelSize: number;
        device: string;
    }>;
    /**
     * Warmup - Initialize BrainyData with preloaded models (container-optimized)
     * For production deployments where models should be ready immediately
     * @param config BrainyData configuration
     * @param options Warmup options
     */
    static warmup(config?: BrainyDataConfig, options?: {
        preloadModel?: boolean;
        modelOptions?: Parameters<typeof BrainyData.preloadModel>[0];
        testEmbedding?: boolean;
    }): Promise<BrainyData>;
    /**
     * Get model size for deployment info
     * @private
     */
    private static getModelSize;
    /**
     * Coordinate storage migration across distributed services
     * @param options Migration options
     */
    coordinateStorageMigration(options: {
        newStorage: any;
        strategy?: 'immediate' | 'gradual' | 'test';
        message?: string;
    }): Promise<void>;
    /**
     * Check for coordination updates
     * Services should call this periodically or on startup
     */
    checkCoordination(): Promise<any>;
    /**
     * Rebuild metadata index
     * Exposed for Cortex reindex command
     */
    rebuildMetadataIndex(): Promise<void>;
    /**
     * 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>;
    /**
     * Restore a soft-deleted noun (complement to consistent soft delete)
     * @param id The noun ID to restore
     * @returns Promise<boolean> True if restored, false if not found or not deleted
     */
    restoreNoun(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(): ImprovedNeuralAPI;
    /**
     * Simple similarity check (shorthand for neural.similar)
     */
    similar(a: any, b: any, options?: any): Promise<number>;
    /**
     * Get semantic clusters (shorthand for neural.clusters)
     */
    clusters(items?: any, options?: any): Promise<any[]>;
    /**
     * Get related items (shorthand for neural.neighbors)
     */
    related(id: string, options?: any): Promise<any[]>;
    /**
     * 🚀 TRIPLE INTELLIGENCE SEARCH - Natural Language & Complex Queries
     * The revolutionary search that combines vector, graph, and metadata intelligence!
     *
     * @param query - Natural language string or structured TripleQuery
     * @param options - Pagination and performance options
     * @returns Unified search results with fusion scoring
     *
     * @example
     * // Natural language query
     * await brain.find('frameworks from recent years with high popularity')
     *
     * // 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
     */
    /**
     * UNIFIED API METHOD #9: Export - Extract your data in various formats
     * Export your brain's knowledge for backup, migration, or integration
     *
     * @param options Export configuration
     * @returns The exported data in the specified format
     */
    export(options?: {
        format?: 'json' | 'csv' | 'graph' | 'embeddings';
        includeVectors?: boolean;
        includeMetadata?: boolean;
        includeRelationships?: boolean;
        filter?: any;
        limit?: number;
    }): Promise<any>;
    /**
     * Helper: Convert data to CSV format
     * @private
     */
    private convertToCSV;
    /**
     * Helper: Convert data to graph format
     * @private
     */
    private convertToGraphFormat;
    /**
     * Unregister an augmentation by name
     * Remove augmentations from the pipeline
     *
     * @param name The name of the augmentation to unregister
     * @returns The BrainyData instance for chaining
     */
    unregister(name: string): this;
    /**
     * Enable an augmentation by name
     * Universal control for built-in, community, and premium augmentations
     *
     * @param name The name of the augmentation to enable
     * @returns True if augmentation was found and enabled
     */
    enableAugmentation(name: string): boolean;
    /**
     * Disable an augmentation by name
     * Universal control for built-in, community, and premium augmentations
     *
     * @param name The name of the augmentation to disable
     * @returns True if augmentation was found and disabled
     */
    disableAugmentation(name: string): boolean;
    /**
     * Check if an augmentation is enabled
     *
     * @param name The name of the augmentation to check
     * @returns True if augmentation is found and enabled, false otherwise
     */
    isAugmentationEnabled(name: string): boolean;
    /**
     * Get all augmentations with their enabled status
     * Shows built-in, community, and premium augmentations
     *
     * @returns Array of augmentations with name, type, and enabled status
     */
    listAugmentations(): Array<{
        name: string;
        type: string;
        enabled: boolean;
        description: string;
    }>;
    /**
     * Enable all augmentations of a specific type
     *
     * @param type The type of augmentations to enable (sense, conduit, cognition, etc.)
     * @returns Number of augmentations enabled
     */
    enableAugmentationType(type: 'sense' | 'conduit' | 'cognition' | 'memory' | 'perception' | 'dialog' | 'activation' | 'webSocket'): number;
    /**
     * Disable all augmentations of a specific type
     *
     * @param type The type of augmentations to disable (sense, conduit, cognition, etc.)
     * @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';