@simonecoelhosfo/optimizely-mcp-server/dist/analytics/intelligent-query-engine/IntelligentQueryEngine.d.ts

Optimizely MCP Server for AI assistants with integrated CLI tools

/**
 * Intelligent Query Engine - Main Entry Point
 *
 * The Intelligent Query Engine provides a universal, extensible query system
 * that automatically discovers field locations, plans optimal execution strategies,
 * and executes queries across different data models.
 */
import { EventEmitter } from 'events';
import { QueryContext, TTLFactors } from './cache/index.js';
import { InvalidationEngine } from './cache/InvalidationEngine.js';
import type { DataModelAdapter, UniversalQuery, QueryResult, ExecutionPlan, EngineConfiguration, PerformanceMetrics } from './types.js';
/**
 * Events emitted by the engine
 */
export interface EngineEvents {
    'query:start': (query: UniversalQuery) => void;
    'query:plan': (plan: ExecutionPlan) => void;
    'query:complete': (result: QueryResult) => void;
    'query:error': (error: Error) => void;
    'adapter:registered': (adapter: DataModelAdapter) => void;
    'performance:metric': (metric: PerformanceMetrics) => void;
}
/**
 * Main Intelligent Query Engine class
 */
export declare class IntelligentQueryEngine extends EventEmitter {
    private fieldCatalog;
    private queryPlanner;
    private hybridExecutor;
    private adapters;
    private queryPatterns;
    private config;
    private cacheOrchestrator;
    private invalidationEngine;
    private syncCacheIntegration?;
    constructor(config?: Partial<EngineConfiguration>);
    /**
     * Register a data model adapter
     */
    registerAdapter(adapter: DataModelAdapter): void;
    /**
     * Execute a query
     */
    query(query: UniversalQuery, options?: {
        bypassCache?: boolean;
        refreshCache?: boolean;
        context?: QueryContext;
        ttlFactors?: Partial<TTLFactors>;
    }): Promise<QueryResult>;
    /**
     * Analyze a query without executing it
     */
    analyze(query: UniversalQuery): Promise<ExecutionPlan>;
    /**
     * Get field information for an entity
     */
    describeEntity(entityName: string): Promise<{
        fields: string[];
        relationships: string[];
    }>;
    /**
     * Track query performance for learning
     */
    private trackPerformance;
    /**
     * Optimize a frequently used query pattern
     */
    private optimizeQueryPattern;
    /**
     * Hash a query for pattern matching
     */
    private hashQuery;
    /**
     * Get engine statistics
     */
    getStatistics(): {
        adapters: string[];
        queryPatterns: number;
        fieldCatalog: any;
        cache: any;
    };
    /**
     * Clear all caches
     */
    clearCaches(): void;
    /**
     * Invalidate cache for specific entities
     */
    invalidateCache(entityType?: string, operation?: string, context?: Partial<QueryContext>): Promise<number>;
    /**
     * Preload cache with common queries
     */
    preloadCache(queries: UniversalQuery[]): Promise<void>;
    /**
     * Get cache metrics
     */
    getCacheMetrics(): {
        hitRate: number;
        entries: number;
        sizeBytes: number;
        recommendedTTLs: Record<string, number>;
    };
    /**
     * Get sync cache integration handler for IncrementalSyncManager
     */
    getSyncCacheHandler(): {
        onSyncStart: (projectId: string) => Promise<void>;
        onSyncComplete: (projectId: string) => Promise<void>;
        onEntitySynced: (event: import("./cache/SyncCacheIntegration.js").SyncEvent) => Promise<void>;
        onBulkSync: (entities: {
            entity: string;
            entityId: string;
        }[], projectId: string) => Promise<void>;
    } | null;
    /**
     * Get invalidation engine for direct access
     */
    getInvalidationEngine(): InvalidationEngine;
    /**
     * Shutdown the engine
     */
    shutdown(): Promise<void>;
}
export * from './types.js';
export { FieldCatalog } from './FieldCatalog.js';
export { QueryPlanner } from './QueryPlanner.js';
export { HybridExecutor } from './HybridExecutor.js';
//# sourceMappingURL=IntelligentQueryEngine.d.ts.map