rcc-virtual-model-rules/dist/VirtualModelRulesModule.d.ts

RCC Virtual Model Rules Module - Claude Code Router rules implementation

/// <reference path="../types/rcc-basemodule.d.ts" />
/// <reference path="../types/index.d.ts" />
import { BaseModule } from 'rcc-basemodule';
import { IVirtualModelRules } from './interfaces/IVirtualModelRules';
import { VirtualModelRule, ModelSchedule, EvaluationContext, EvaluationResult, RuleMetrics } from './types/VirtualModelRulesTypes';
/**
 * Virtual Model Rules Module for RCC
 * Manages intelligent routing rules, model scheduling, and request processing
 * based on Claude Code Router patterns and virtual model capabilities
 */
export declare class VirtualModelRulesModule extends BaseModule implements IVirtualModelRules {
    private rules;
    private schedules;
    private ruleMetrics;
    private evaluationContext;
    private isInitialized;
    private ruleExecutionCache;
    private cacheCleanupInterval;
    constructor();
    /**
     * Configure the virtual model rules module
     */
    configure(config: any): void;
    /**
     * Initialize the virtual model rules module
     */
    initialize(): Promise<void>;
    /**
     * Register a virtual model rule
     */
    registerRule(rule: VirtualModelRule): Promise<void>;
    /**
     * Unregister a virtual model rule
     */
    unregisterRule(ruleId: string): Promise<void>;
    /**
     * Get a rule by ID
     */
    getRule(ruleId: string): VirtualModelRule | undefined;
    /**
     * Get all rules
     */
    getRules(): VirtualModelRule[];
    /**
     * Get rules for a specific model
     */
    getRulesForModel(modelId: string): VirtualModelRule[];
    /**
     * Evaluate rules for a given context
     */
    evaluateRules(context: EvaluationContext): Promise<EvaluationResult[]>;
    /**
     * Get rule metrics
     */
    getRuleMetrics(ruleId?: string): RuleMetrics[];
    /**
     * Load rules from configuration file
     */
    loadRules(rulesPath: string): Promise<void>;
    /**
     * Add a new virtual model rule (alias for registerRule)
     */
    addRule(rule: VirtualModelRule): Promise<void>;
    /**
     * Remove a virtual model rule (alias for unregisterRule)
     */
    removeRule(ruleId: string): Promise<void>;
    /**
     * Update an existing rule
     */
    updateRule(ruleId: string, updates: Partial<VirtualModelRule>): Promise<void>;
    /**
     * Get model schedule (alias for getSchedule)
     */
    getModelSchedule(modelId: string): ModelSchedule | undefined;
    /**
     * Set model schedule (alias for registerSchedule)
     */
    setModelSchedule(modelId: string, schedule: ModelSchedule): Promise<void>;
    /**
     * Get active rules for model
     */
    getActiveRules(modelId: string): VirtualModelRule[];
    /**
     * Enable/disable rule
     */
    setRuleEnabled(ruleId: string, enabled: boolean): Promise<void>;
    /**
     * Register a model schedule
     */
    registerSchedule(schedule: ModelSchedule): Promise<void>;
    /**
     * Unregister a model schedule
     */
    unregisterSchedule(modelId: string): Promise<void>;
    /**
     * Get schedule for a model
     */
    getSchedule(modelId: string): ModelSchedule | undefined;
    /**
     * Get all schedules
     */
    getSchedules(): ModelSchedule[];
    /**
     * Check if a model is currently scheduled to run
     */
    isModelScheduled(modelId: string): Promise<boolean>;
    /**
     * Get configuration
     */
    getConfig(): any;
    /**
     * Update configuration
     */
    updateConfig(config: any): Promise<void>;
    /**
     * Handle incoming messages
     */
    handleMessage(message: any): Promise<any>;
    /**
     * Cleanup resources
     */
    destroy(): Promise<void>;
    /**
     * Initialize rule engine
     */
    private initializeRuleEngine;
    /**
     * Setup message handlers
     */
    private setupMessageHandlers;
    /**
     * Start cache cleanup
     */
    private startCacheCleanup;
    /**
     * Validate rule configuration
     */
    private validateRule;
    /**
     * Validate schedule configuration
     */
    private validateSchedule;
    /**
     * Get applicable rules for a context
     */
    private getApplicableRules;
    /**
     * Evaluate a single rule
     */
    private evaluateRule;
    /**
     * Evaluate rule conditions
     */
    private evaluateConditions;
    /**
     * Evaluate a single condition
     */
    private evaluateCondition;
    /**
     * Get field value from context
     */
    private getFieldValue;
    /**
     * Execute rule actions
     */
    private executeActions;
    /**
     * Execute a single action
     */
    private executeAction;
    /**
     * Execute route to model action
     */
    private executeRouteToModel;
    /**
     * Execute set priority action
     */
    private executeSetPriority;
    /**
     * Execute add tag action
     */
    private executeAddTag;
    /**
     * Execute remove tag action
     */
    private executeRemoveTag;
    /**
     * Execute log event action
     */
    private executeLogEvent;
    /**
     * Create evaluation result
     */
    private createEvaluationResult;
    /**
     * Update rule metrics
     */
    private updateRuleMetrics;
    /**
     * Get cache key for rule evaluation
     */
    private getCacheKey;
    /**
     * Clear cache entries for a rule
     */
    private clearRuleCache;
    /**
     * Cleanup expired cache entries
     */
    private cleanupCache;
    /**
     * Check if schedule is currently active
     */
    private isScheduleActive;
    /**
     * Handle rule evaluation message
     */
    private handleRuleEvaluation;
    /**
     * Handle schedule status message
     */
    private handleScheduleStatus;
    /**
     * Handle rule metrics message
     */
    private handleRuleMetrics;
}
//# sourceMappingURL=VirtualModelRulesModule.d.ts.map