@simonecoelhosfo/optimizely-mcp-server/dist/cli/core/ReferenceResolver.d.ts

Optimizely MCP Server for AI assistants with integrated CLI tools

/**
 * Reference Resolver
 *
 * Handles entity reference resolution with multiple strategies:
 * - By ID (direct lookup)
 * - By name (search and match)
 * - By key (for entities that support keys)
 * - Auto-create (if not found and configured)
 * - Step references (${step_id.field})
 */
export interface EntityReference {
    ref: {
        id?: string | number;
        name?: string;
        key?: string;
        auto_create?: boolean;
        create_template?: any;
    };
}
export interface ResolvedReference {
    method: 'id' | 'name' | 'key' | 'name_fuzzy' | 'will_create' | 'error' | 'step_reference';
    entity?: any;
    id?: string | number;
    matchedBy?: string;
    confidence?: number;
    template?: any;
    reason?: string;
    error?: string;
    suggestion?: string;
    found: boolean;
}
export interface ResolutionContext {
    projectId: string;
    entityType: string;
    platform?: string;
    availableSteps?: Map<string, any>;
}
export interface LookupStrategy {
    name: string;
    resolve: (ref: EntityReference, context: ResolutionContext) => Promise<ResolvedReference>;
}
interface OptimizelyAPIClient {
    getEntity(entityType: string, id: string | number, projectId: string): Promise<any>;
    listEntities(entityType: string, projectId: string, filters?: any): Promise<any[]>;
}
export declare class ReferenceResolver {
    private entityCache;
    private lookupStrategies;
    private apiClient;
    constructor(apiClient?: OptimizelyAPIClient);
    /**
     * Resolves an entity reference with multiple fallback strategies
     */
    resolveReference(ref: EntityReference | string, context: ResolutionContext): Promise<ResolvedReference>;
    /**
     * Resolve a step reference like ${step_id.field}
     */
    private resolveStepReference;
    /**
     * Initialize lookup strategies
     */
    private initializeStrategies;
    /**
     * Get strategies for a specific entity type
     */
    private getStrategiesFor;
    /**
     * Fuzzy match by name
     */
    private fuzzyMatchByName;
    /**
     * Get cache key for a reference
     */
    private getCacheKey;
    /**
     * Get helpful suggestion for resolution errors
     */
    private getSuggestion;
    /**
     * Resolve all references in a template
     */
    resolveTemplateReferences(template: any, projectId: string, platform?: string): Promise<Map<string, ResolvedReference>>;
    /**
     * Get fields that typically contain references for an entity type
     */
    private getReferenceFieldsForEntity;
    /**
     * Extract entity type from system template ID
     */
    private extractEntityType;
    /**
     * Create a mock API client for testing
     */
    private createMockApiClient;
}
export {};
//# sourceMappingURL=ReferenceResolver.d.ts.map