@simonecoelhosfo/optimizely-mcp-server/dist/templates/UpdateTemplateProcessor.d.ts

Optimizely MCP Server for AI assistants with integrated CLI tools

/**
 * Update Template Processor
 *
 * Processes UPDATE templates by merging template data with existing entity data,
 * validating update compatibility, and preparing processed templates for orchestration.
 *
 * Key Responsibilities:
 * - Merge template data with existing entity state
 * - Validate update operations won't break existing configurations
 * - Process template placeholders with context-aware resolution
 * - Prepare processed templates for EntityOrchestrator UPDATE methods
 *
 * Template Placeholder Processing:
 * - {EXISTING: field} → Extract from existing entity
 * - {CURRENT: field} → Show current value for context
 * - {FILL: field} → Validate required fields are provided
 * - {OPTIONAL: field} → Handle optional fields gracefully
 * - {REBALANCE: weights} → Auto-calculate traffic distributions
 *
 * @author Optimizely MCP Server
 * @version 1.0.0
 */
import { UpdateTemplate } from './UpdateEntityTemplates.js';
export interface ProcessedUpdateTemplate {
    originalTemplate: UpdateTemplate;
    processedData: any;
    existingEntityData: any;
    mergeStrategy: 'replace' | 'merge' | 'additive' | 'rebalance';
    validationResults: ValidationResult;
    contextualData: {
        currentValues: Record<string, any>;
        extractedReferences: Record<string, any>;
        autoCalculations: Record<string, any>;
    };
    orchestrationHints: {
        requiredOperations: string[];
        affectedEntities: string[];
        createdEntities: string[];
        riskLevel: 'low' | 'medium' | 'high';
    };
}
export interface ValidationResult {
    isValid: boolean;
    errors: string[];
    warnings: string[];
    requiredFields: string[];
    conflictingFields: string[];
    safetyChecks: {
        trafficTotals?: number;
        breakingChanges?: string[];
        dependencyIssues?: string[];
    };
}
export interface UpdateTemplateContext {
    projectId: string;
    platform: 'feature' | 'web' | 'auto';
    environment?: string;
    existingEntity: any;
    relatedEntities?: Record<string, any[]>;
}
export declare class UpdateTemplateProcessor {
    private logger;
    private validator;
    private payloadParser;
    /**
     * Process an UPDATE template with existing entity data
     */
    processUpdateTemplate(template: UpdateTemplate, templateData: any, context: UpdateTemplateContext): Promise<ProcessedUpdateTemplate>;
    /**
     * CRITICAL: Apply intelligent corrections and parsing to processed data
     * This ensures ALL UPDATE template data goes through our auto-correction pipeline
     */
    private applyIntelligentCorrections;
    /**
     * Apply weight corrections (percentage to basis points)
     */
    private applyWeightCorrections;
    /**
     * Apply audience_conditions formatting (object to JSON string)
     */
    private applyAudienceConditionsFormatting;
    /**
     * Apply Feature Experimentation specific corrections
     */
    private applyFeatureExperimentationCorrections;
    /**
     * Apply Web Experimentation specific corrections
     */
    private applyWebExperimentationCorrections;
    /**
     * Extract contextual data from existing entity and related entities
     */
    private extractContextualData;
    /**
     * Process template placeholders with context-aware resolution
     */
    private processTemplatePlaceholders;
    /**
     * Resolve individual template placeholders
     */
    private resolvePlaceholder;
    /**
     * Get value from template data using dot notation
     */
    private getTemplateDataValue;
    /**
     * Calculate traffic rebalancing for variations
     */
    private calculateTrafficRebalancing;
    /**
     * Validate update template for compatibility and safety
     */
    private validateUpdateTemplate;
    /**
     * Validate required fields using OpenAPI schema
     */
    private validateRequiredFields;
    /**
     * Validate field type matches schema expectation
     */
    private validateFieldType;
    /**
     * Validate compatibility with existing entity
     */
    private validateCompatibility;
    /**
     * Perform safety checks for destructive operations
     */
    private performSafetyChecks;
    /**
     * Calculate total traffic allocation
     */
    private calculateTrafficTotal;
    /**
     * Generate orchestration hints for EntityOrchestrator
     */
    private generateOrchestrationHints;
    /**
     * Merge template with existing entity data based on update type
     */
    mergeTemplateWithExisting(processedTemplate: any, existingEntity: any, updateType: 'replace' | 'merge' | 'additive' | 'rebalance'): Promise<any>;
    /**
     * Perform additive operations (add new items to arrays)
     */
    private performAdditiveOperation;
    /**
     * Perform rebalance operations (recalculate weights)
     */
    private performRebalanceOperation;
    /**
     * Remove null, undefined, and empty fields from processed data
     * This ensures PATCH operations only include fields that are actually being updated
     */
    private removeNullFields;
}
//# sourceMappingURL=UpdateTemplateProcessor.d.ts.map