@codai/memorai/dist/types.d.ts

Universal Database & Storage Service for CODAI Ecosystem - CBD Backend

/**
 * Universal Types for MEMORAI Database & Storage Service
 */
export interface MemoraiConfig {
    database: {
        url: string;
        type: 'postgresql' | 'mysql' | 'sqlite' | 'mongodb';
        provider?: string;
        maxConnections: number;
        connectionTimeout: number;
        queryTimeout: number;
        ssl?: boolean;
        logging?: boolean;
        migrations?: {
            auto: boolean;
            directory: string;
        };
    };
    vectorDB: {
        url: string;
        type: 'pinecone' | 'weaviate' | 'qdrant' | 'chroma' | 'local';
        apiKey?: string;
        dimensions: number;
        metric: 'cosine' | 'euclidean' | 'dotproduct';
        indexName: string;
    };
    storage: {
        provider: 'local' | 'aws-s3' | 'cloudflare-r2' | 'supabase' | 'vercel-blob';
        bucket: string;
        region?: string;
        accessKey?: string;
        secretKey?: string;
        publicUrl?: string;
        maxFileSize: number;
        allowedTypes: string[];
        enableCDN: boolean;
    };
    cache: {
        provider: 'redis' | 'memory' | 'upstash';
        url?: string;
        password?: string;
        ttl: number;
        maxSize: number;
    };
    ai: {
        provider: 'openai' | 'anthropic' | 'local';
        apiKey?: string;
        model: string;
        embeddingModel: string;
        maxTokens: number;
    };
    realtime: {
        enabled: boolean;
        provider: 'socket.io' | 'supabase' | 'pusher';
        url?: string;
        apiKey?: string;
        secret?: string;
    };
    security: {
        encryption: {
            enabled: boolean;
            algorithm: string;
            key?: string;
        };
        rateLimit: {
            enabled: boolean;
            windowMs: number;
            maxRequests: number;
        };
        cors: {
            origins: string[];
            credentials: boolean;
        };
    };
    performance: {
        queryOptimization: boolean;
        indexOptimization: boolean;
        compressionEnabled: boolean;
        batchSize: number;
        cacheStrategy: 'aggressive' | 'balanced' | 'conservative';
    };
}
export interface MemoraiEntity {
    id: string;
    createdAt: Date;
    updatedAt: Date;
    version: number;
    metadata?: Record<string, any>;
}
export interface User extends MemoraiEntity {
    email: string;
    name: string;
    avatar?: string;
    preferences: UserPreferences;
    subscription?: Subscription;
    storageUsed: number;
    storageLimit: number;
}
export interface UserPreferences {
    theme: 'light' | 'dark' | 'system';
    language: string;
    timezone: string;
    notifications: NotificationPreferences;
    privacy: PrivacySettings;
}
export interface NotificationPreferences {
    email: boolean;
    push: boolean;
    inApp: boolean;
    digest: 'realtime' | 'hourly' | 'daily' | 'weekly';
}
export interface PrivacySettings {
    shareData: boolean;
    allowAnalytics: boolean;
    publicProfile: boolean;
}
export interface Subscription {
    plan: 'free' | 'pro' | 'enterprise';
    status: 'active' | 'cancelled' | 'expired';
    startDate: Date;
    endDate?: Date;
    features: string[];
}
export interface DatabaseRecord extends MemoraiEntity {
    table: string;
    data: Record<string, any>;
    schema?: string;
    indexes: string[];
    relations: DatabaseRelation[];
}
export interface DatabaseRelation {
    type: 'one-to-one' | 'one-to-many' | 'many-to-many';
    target: string;
    foreignKey: string;
    references: string;
}
export interface DatabaseQuery {
    table: string;
    operation: 'select' | 'insert' | 'update' | 'delete';
    conditions?: QueryCondition[];
    fields?: string[];
    data?: Record<string, any>;
    limit?: number;
    offset?: number;
    orderBy?: OrderBy[];
    joins?: Join[];
}
export interface QueryCondition {
    field: string;
    operator: '=' | '!=' | '>' | '<' | '>=' | '<=' | 'IN' | 'NOT IN' | 'LIKE' | 'NOT LIKE' | 'IS NULL' | 'IS NOT NULL';
    value: any;
    connector?: 'AND' | 'OR';
}
export interface OrderBy {
    field: string;
    direction: 'ASC' | 'DESC';
}
export interface Join {
    type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
    table: string;
    condition: string;
}
export interface StorageFile extends MemoraiEntity {
    filename: string;
    originalName: string;
    mimeType: string;
    size: number;
    path: string;
    url: string;
    hash: string;
    userId: string;
    tags: string[];
    isPublic: boolean;
    downloadCount: number;
    expiresAt?: Date;
}
export interface StorageUpload {
    file: Buffer | ReadableStream;
    filename: string;
    mimeType: string;
    size?: number;
    isPublic?: boolean;
    tags?: string[];
    expiresAt?: Date;
}
export interface StorageProvider {
    upload(file: StorageUpload, path: string): Promise<StorageFile>;
    download(path: string): Promise<Buffer>;
    delete(path: string): Promise<boolean>;
    getUrl(path: string, expiresIn?: number): Promise<string>;
    list(prefix?: string): Promise<StorageFile[]>;
    copy(fromPath: string, toPath: string): Promise<boolean>;
    move(fromPath: string, toPath: string): Promise<boolean>;
}
export interface Memory extends MemoraiEntity {
    userId: string;
    appId: string;
    content: string;
    type: 'episodic' | 'semantic' | 'procedural' | 'working' | 'autobiographical';
    importance: number;
    confidence: number;
    context: MemoryContext;
    embeddings: number[];
    relationships: MemoryRelationship[];
    accessHistory: MemoryAccess[];
    tags: string[];
    isShared: boolean;
    sharedWith: string[];
    expiresAt?: Date;
}
export interface MemoryContext {
    sessionId?: string;
    conversationId?: string;
    taskId?: string;
    location?: string;
    temporalContext: TemporalContext;
    emotionalState?: EmotionalState;
    cognitiveLoad?: number;
    environmentalFactors: Record<string, any>;
}
export interface TemporalContext {
    timeOfDay: string;
    dayOfWeek: string;
    season: string;
    timeZone: string;
    relativeTime: 'recent' | 'medium' | 'distant';
}
export interface EmotionalState {
    valence: number;
    arousal: number;
    dominance: number;
    emotions: string[];
}
export interface MemoryRelationship {
    id: string;
    relatedMemoryId: string;
    type: 'causal' | 'temporal' | 'semantic' | 'contextual' | 'associative';
    strength: number;
    direction: 'bidirectional' | 'unidirectional';
    createdAt: Date;
    lastReinforced: Date;
}
export interface MemoryAccess {
    timestamp: Date;
    accessType: 'read' | 'update' | 'link' | 'consolidate';
    userId: string;
    appId: string;
    context: string;
    reinforcement: number;
}
export interface MemoryQuery {
    text?: string;
    embeddings?: number[];
    type?: Memory['type'];
    userId?: string;
    appId?: string;
    timeRange?: {
        start: Date;
        end: Date;
    };
    importance?: {
        min: number;
        max: number;
    };
    confidence?: {
        min: number;
        max: number;
    };
    tags?: string[];
    limit?: number;
    includeRelated?: boolean;
    semanticThreshold?: number;
}
export interface MemorySearchResult {
    memory: Memory;
    similarity: number;
    relevanceScore: number;
    contextMatch: number;
    explanation: string;
}
export interface VectorDocument extends MemoraiEntity {
    documentId: string;
    content: string;
    embeddings: number[];
    metadata: DocumentMetadata;
    chunks: VectorChunk[];
    lastIndexed: Date;
}
export interface DocumentMetadata {
    title?: string;
    author?: string;
    source?: string;
    language?: string;
    contentType: string;
    size: number;
    tags: string[];
    customFields: Record<string, any>;
}
export interface VectorChunk {
    id: string;
    content: string;
    embeddings: number[];
    startIndex: number;
    endIndex: number;
    metadata: Record<string, any>;
}
export interface VectorSearchQuery {
    query: string;
    embeddings?: number[];
    limit?: number;
    threshold?: number;
    filters?: Record<string, any>;
    includeMetadata?: boolean;
    includeContent?: boolean;
}
export interface VectorSearchResult {
    document: VectorDocument;
    chunk?: VectorChunk;
    score: number;
    distance: number;
    metadata: Record<string, any>;
}
export interface SyncOperation extends MemoraiEntity {
    userId: string;
    appId: string;
    operation: 'insert' | 'update' | 'delete';
    table: string;
    recordId: string;
    data?: Record<string, any>;
    previousData?: Record<string, any>;
    status: 'pending' | 'synced' | 'failed' | 'conflict';
    syncedAt?: Date;
    retryCount: number;
    error?: string;
    priority: number;
}
export interface SyncConflict extends MemoraiEntity {
    syncOperationId: string;
    conflictType: 'concurrent_update' | 'deleted_record' | 'schema_mismatch';
    localData: Record<string, any>;
    remoteData: Record<string, any>;
    resolution?: 'use_local' | 'use_remote' | 'merge' | 'manual';
    resolvedData?: Record<string, any>;
    resolvedAt?: Date;
    resolvedBy?: string;
}
export interface SyncStatus {
    appId: string;
    lastSync: Date;
    pendingOperations: number;
    failedOperations: number;
    conflicts: number;
    isOnline: boolean;
    syncInProgress: boolean;
}
export interface CacheEntry<T = any> {
    key: string;
    value: T;
    expiresAt: Date;
    tags: string[];
    version: number;
    metadata?: Record<string, any>;
}
export interface CacheOptions {
    ttl?: number;
    tags?: string[];
    compression?: boolean;
    encryption?: boolean;
    metadata?: Record<string, any>;
}
export interface CacheStats {
    totalKeys: number;
    memoryUsage: number;
    hitRate: number;
    missRate: number;
    evictionCount: number;
    expiredCount: number;
}
export interface MemoraiEvent {
    id: string;
    type: string;
    source: string;
    data: Record<string, any>;
    timestamp: Date;
    userId?: string;
    appId?: string;
    metadata?: Record<string, any>;
}
export interface EventSubscription {
    id: string;
    userId: string;
    appId: string;
    eventTypes: string[];
    endpoint: string;
    isActive: boolean;
    lastDelivery?: Date;
    failureCount: number;
}
export interface APIResponse<T = any> {
    success: boolean;
    data?: T;
    error?: string;
    message?: string;
    timestamp: Date;
    requestId: string;
    metadata?: Record<string, any>;
}
export interface PaginatedResponse<T = any> extends APIResponse<T[]> {
    pagination: {
        page: number;
        limit: number;
        total: number;
        totalPages: number;
        hasNextPage: boolean;
        hasPreviousPage: boolean;
    };
}
export interface BatchOperation<T = any> {
    operation: 'insert' | 'update' | 'delete';
    data: T;
    id?: string;
}
export interface BatchResponse<T = any> {
    success: boolean;
    results: BatchOperationResult<T>[];
    summary: {
        total: number;
        successful: number;
        failed: number;
        skipped: number;
    };
}
export interface BatchOperationResult<T = any> {
    success: boolean;
    data?: T;
    error?: string;
    operation: BatchOperation<T>;
}
export interface AnalyticsEvent {
    eventName: string;
    userId?: string;
    appId: string;
    properties: Record<string, any>;
    timestamp: Date;
    sessionId?: string;
    deviceId?: string;
    userAgent?: string;
    ipAddress?: string;
}
export interface AnalyticsQuery {
    eventName?: string;
    userId?: string;
    appId?: string;
    startDate: Date;
    endDate: Date;
    groupBy?: string[];
    filters?: Record<string, any>;
    aggregations?: AnalyticsAggregation[];
}
export interface AnalyticsAggregation {
    field: string;
    operation: 'sum' | 'count' | 'avg' | 'min' | 'max' | 'distinct';
}
export interface AnalyticsResult {
    data: Record<string, any>[];
    summary: {
        totalEvents: number;
        uniqueUsers: number;
        dateRange: {
            start: Date;
            end: Date;
        };
        aggregations: Record<string, number>;
    };
}
export type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
export type RequiredFields<T, K extends keyof T> = T & Required<Pick<T, K>>;
export type OptionalFields<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
export type Timestamp = Date | string | number;
export type UUID = string;
export type JSONValue = string | number | boolean | null | JSONObject | JSONArray;
export interface JSONObject {
    [key: string]: JSONValue;
}
export interface JSONArray extends Array<JSONValue> {
}
export interface MemoraiError {
    code: string;
    message: string;
    details?: Record<string, any>;
    stack?: string;
    timestamp: Date;
    requestId?: string;
    userId?: string;
    appId?: string;
}
export declare class MemoraiException extends Error {
    readonly code: string;
    readonly details?: Record<string, any>;
    readonly timestamp: Date;
    readonly requestId?: string;
    readonly userId?: string;
    readonly appId?: string;
    constructor(code: string, message: string, details?: Record<string, any>, requestId?: string, userId?: string, appId?: string);
    toJSON(): MemoraiError;
}
//# sourceMappingURL=types.d.ts.map