@codai/memorai/dist/services/MemoraiService.d.ts

Universal Database & Storage Service for CODAI Ecosystem - CBD Backend

/**
 * MemoraiService - Universal Database & Storage Service
 *
 * Main service class that orchestrates all MEMORAI functionality:
 * - Database operations (SQL, NoSQL, Vector)
 * - File & Blob storage
 * - AI Memory management
 * - Real-time synchronization
 * - Cross-app data sharing
 */
import { EventEmitter } from 'events';
import type { MemoraiConfig, Memory, MemoryQuery, MemorySearchResult, StorageFile, StorageUpload, DatabaseQuery, APIResponse, PaginatedResponse, AnalyticsEvent, CacheOptions } from '../types';
import { DatabaseService } from './DatabaseService';
import { StorageService } from './StorageService';
import { MemoryService } from './MemoryService';
import { SyncService } from './SyncService';
import { CacheService } from './CacheService';
import { AnalyticsService } from './AnalyticsService';
export declare class MemoraiService extends EventEmitter {
    private static instance;
    private config;
    private isInitialized;
    readonly database: DatabaseService;
    readonly storage: StorageService;
    readonly memory: MemoryService;
    readonly sync: SyncService;
    readonly cache: CacheService;
    readonly analytics: AnalyticsService;
    private constructor();
    static getInstance(config?: Partial<MemoraiConfig>): MemoraiService;
    static create(config?: Partial<MemoraiConfig>): Promise<MemoraiService>;
    initialize(): Promise<void>;
    shutdown(): Promise<void>;
    query<T = any>(query: DatabaseQuery): Promise<APIResponse<T[]>>;
    insert<T = any>(table: string, data: Partial<T>): Promise<APIResponse<T>>;
    update<T = any>(table: string, id: string, data: Partial<T>): Promise<APIResponse<T>>;
    delete(table: string, id: string): Promise<APIResponse<boolean>>;
    find<T = any>(table: string, conditions?: DatabaseQuery['conditions'], options?: {
        limit?: number;
        offset?: number;
        orderBy?: DatabaseQuery['orderBy'];
    }): Promise<PaginatedResponse<T>>;
    storeMemory(memory: Partial<Memory>): Promise<APIResponse<Memory>>;
    searchMemories(query: MemoryQuery): Promise<APIResponse<MemorySearchResult[]>>;
    getMemory(id: string, userId: string): Promise<APIResponse<Memory | null>>;
    uploadFile(file: StorageUpload, userId: string): Promise<APIResponse<StorageFile>>;
    downloadFile(fileId: string, userId: string): Promise<APIResponse<Buffer>>;
    deleteFile(fileId: string, userId: string): Promise<APIResponse<boolean>>;
    trackEvent(event: AnalyticsEvent): Promise<APIResponse<boolean>>;
    cacheGet<T = any>(key: string): Promise<T | null>;
    cacheSet<T = any>(key: string, value: T, options?: CacheOptions): Promise<void>;
    cacheDelete(key: string): Promise<boolean>;
    cacheClear(pattern?: string): Promise<number>;
    getHealth(): Promise<{
        status: 'healthy' | 'degraded' | 'unhealthy';
        services: Record<string, {
            status: string;
            latency?: number;
            error?: string;
        }>;
        timestamp: Date;
    }>;
    private setupEventHandlers;
    private generateQueryCacheKey;
    private generateFindCacheKey;
    private calculatePagination;
    private generateRequestId;
    get isReady(): boolean;
    get configuration(): MemoraiConfig;
}
export declare const memorai: MemoraiService;
export default MemoraiService;
//# sourceMappingURL=MemoraiService.d.ts.map