import type { HTMLAttributes } from 'svelte/elements';
export type OperationPriority = 'low' | 'normal' | 'high' | 'urgent';
export type OperationStatus = 'pending' | 'executing' | 'completed' | 'failed';
export type DataType = 'sql' | 'vector' | 'graph';
export type ConflictStrategy = 'reject' | 'overwrite' | 'merge';
export type CacheStrategy = 'default' | 'aggressive' | 'minimal' | 'bypass';
export type LibrarianRole = 'scribe' | 'reference-librarian' | 'specialist';
export type AgentStatus = 'available' | 'busy' | 'offline' | 'error';
export type ConsistencyCheckType = 'pre-write' | 'post-write' | 'scheduled' | 'manual';
export interface WriteOperation {
    id: string;
    operation: string;
    dataType: DataType;
    targetDatabase: string;
    priority: OperationPriority;
    status: OperationStatus;
    createdAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    requiresTransaction: boolean;
    expectedDataSize: number;
    conflictStrategy: ConflictStrategy;
    scribeAgentId: string;
    assignedWorkers: string[];
    result?: {
        recordsAffected: number;
        executionTime: number;
        dataSize: number;
        transactionId?: string;
    };
    error?: string;
    metadata?: Record<string, any>;
    tags?: string[];
}
export interface ReadOperation {
    id: string;
    query: string;
    dataType: DataType;
    targetDatabase: string;
    priority: OperationPriority;
    status: OperationStatus;
    createdAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    expectedResultSize: number;
    cacheStrategy: CacheStrategy;
    referenceLibrarianId: string;
    specialists: string[];
    result?: {
        records: any[];
        executionTime: number;
        dataSize: number;
        cacheHit?: boolean;
        queryPlan?: any;
    };
    error?: string;
    optimizationHints?: {
        useIndex?: string[];
        joinStrategy?: string;
        parallelization?: boolean;
    };
    metadata?: Record<string, any>;
    tags?: string[];
}
export interface LibrarianAgent {
    id: string;
    role: LibrarianRole;
    specialization: string;
    status: AgentStatus;
    supportedDataTypes: DataType[];
    maxConcurrentOperations: number;
    currentOperations: string[];
    lastActivity: Date;
    averageExecutionTime: number;
    successRate: number;
    totalOperationsCompleted: number;
    capabilities: {
        canOptimizeQueries: boolean;
        canHandleTransactions: boolean;
        canPerformConsistencyChecks: boolean;
        maxDataSizeKB: number;
    };
    preferences?: {
        preferredOperationTypes: string[];
        workingHours?: {
            start: string;
            end: string;
            timezone: string;
        };
    };
    version: string;
    endpoint?: string;
    description?: string;
}
export interface DataConsistencyCheck {
    id: string;
    triggeredByOperation: string;
    dataType: DataType;
    targetDatabase: string;
    checkType: ConsistencyCheckType;
    status: OperationStatus;
    createdAt: Date;
    startedAt?: Date;
    completedAt?: Date;
    consistent: boolean;
    issues?: string[];
    severity?: 'low' | 'medium' | 'high' | 'critical';
    checkScope: {
        tables?: string[];
        indices?: string[];
        constraints?: string[];
        relationships?: string[];
    };
    recommendedActions?: string[];
    autoFixApplied?: boolean;
    executionTime?: number;
    dataScanned?: number;
}
export interface OrchestrationConfig {
    /**
     * Maximum concurrent write operations
     * @default 3
     */
    maxConcurrentWrites: number;
    /**
     * Maximum concurrent read operations
     * @default 10
     */
    maxConcurrentReads: number;
    /**
     * Timeout for write operations in milliseconds
     * @default 30000
     */
    writeTimeout: number;
    /**
     * Timeout for read operations in milliseconds
     * @default 15000
     */
    readTimeout: number;
    /**
     * Enable conflict detection for write operations
     * @default true
     */
    enableConflictDetection: boolean;
    /**
     * Enable transaction support
     * @default true
     */
    enableTransactions: boolean;
    /**
     * Advanced configuration
     */
    queueManagement?: {
        maxQueueSize: number;
        priorityWeights: Record<OperationPriority, number>;
        agingFactor: number;
    };
    consistencyChecking?: {
        enableAutomaticChecks: boolean;
        checkInterval: number;
        maxInconsistencyThreshold: number;
    };
    loadBalancing?: {
        strategy: 'round-robin' | 'least-loaded' | 'capability-based';
        healthCheckInterval: number;
        failoverEnabled: boolean;
    };
}
export interface ReadWriteOrchestrationPanelProps extends HTMLAttributes<HTMLDivElement> {
    /**
     * Current write operations
     */
    writeOperations?: WriteOperation[];
    /**
     * Current read operations
     */
    readOperations?: ReadOperation[];
    /**
     * Available librarian agents
     */
    librarianAgents?: LibrarianAgent[];
    /**
     * Data consistency check results
     */
    consistencyChecks?: DataConsistencyCheck[];
    /**
     * Show write orchestration section
     * @default true
     */
    showWriteOrchestration?: boolean;
    /**
     * Show read orchestration section
     * @default true
     */
    showReadOrchestration?: boolean;
    /**
     * Show consistency monitoring section
     * @default true
     */
    showConsistencyMonitoring?: boolean;
    /**
     * Enable operation queuing and automatic processing
     * @default true
     */
    enableOperationQueuing?: boolean;
    /**
     * Orchestration system configuration
     */
    orchestrationConfig?: OrchestrationConfig;
    /**
     * Callback when write operation is created
     */
    onWriteOperation?: (operation: WriteOperation) => void;
    /**
     * Callback when read operation is created
     */
    onReadOperation?: (operation: ReadOperation) => void;
    /**
     * Callback when consistency issue is detected
     */
    onConsistencyIssue?: (check: DataConsistencyCheck) => void;
    /**
     * Callback when librarian agents are assigned to operations
     */
    onLibrarianAssignment?: (operation: WriteOperation | ReadOperation, assignedAgents: string[]) => void;
    /**
     * Callback when operation status changes
     */
    onOperationStatusChanged?: (operationId: string, status: OperationStatus) => void;
    /**
     * Callback when agent status changes
     */
    onAgentStatusChanged?: (agentId: string, status: AgentStatus) => void;
}
export interface WriteOrchestrator {
    /**
     * Queue write operation for execution
     */
    queueWriteOperation: (operation: WriteOperation) => Promise<void>;
    /**
     * Execute write operation with Scribe coordination
     */
    executeWriteOperation: (operation: WriteOperation, scribeAgent: LibrarianAgent, workers: LibrarianAgent[]) => Promise<WriteOperationResult>;
    /**
     * Validate write operation before execution
     */
    validateWriteOperation: (operation: WriteOperation) => Promise<ValidationResult>;
    /**
     * Handle write conflicts
     */
    resolveWriteConflict: (operation: WriteOperation, conflict: WriteConflict) => Promise<ConflictResolution>;
}
export interface ReadOrchestrator {
    /**
     * Queue read operation for execution
     */
    queueReadOperation: (operation: ReadOperation) => Promise<void>;
    /**
     * Execute read operation with Reference Librarian coordination
     */
    executeReadOperation: (operation: ReadOperation, librarian: LibrarianAgent, specialists: LibrarianAgent[]) => Promise<ReadOperationResult>;
    /**
     * Optimize read query
     */
    optimizeQuery: (operation: ReadOperation, optimizer: LibrarianAgent) => Promise<OptimizedQuery>;
    /**
     * Handle cache strategies
     */
    manageCaching: (operation: ReadOperation, cacheManager: LibrarianAgent) => Promise<CacheResult>;
}
export interface WriteOperationResult {
    success: boolean;
    recordsAffected: number;
    executionTime: number;
    transactionId?: string;
    dataIntegrityCheck?: boolean;
    warnings?: string[];
    error?: string;
}
export interface ReadOperationResult {
    success: boolean;
    records: any[];
    executionTime: number;
    cacheHit: boolean;
    queryOptimizations?: string[];
    warnings?: string[];
    error?: string;
}
export interface ValidationResult {
    valid: boolean;
    issues?: string[];
    suggestions?: string[];
    estimatedComplexity: 'low' | 'medium' | 'high';
    requiresSpecialHandling: boolean;
}
export interface WriteConflict {
    type: 'unique_constraint' | 'foreign_key' | 'data_type' | 'business_rule';
    details: string;
    affectedRecords: number;
    suggestedResolution: ConflictStrategy;
}
export interface ConflictResolution {
    strategy: ConflictStrategy;
    applied: boolean;
    result?: WriteOperationResult;
    additionalActions?: string[];
}
export interface OptimizedQuery {
    originalQuery: string;
    optimizedQuery: string;
    optimizations: string[];
    estimatedSpeedup: number;
    indexRecommendations?: string[];
}
export interface CacheResult {
    hit: boolean;
    key: string;
    ttl?: number;
    size?: number;
    source: 'memory' | 'disk' | 'distributed';
}
export interface ScribeAgent extends LibrarianAgent {
    role: 'scribe';
    writeCapabilities: {
        supportedOperations: string[];
        transactionSupport: boolean;
        bulkOperationSupport: boolean;
        conflictResolutionStrategies: ConflictStrategy[];
    };
    dataIntegrityFeatures: {
        automaticValidation: boolean;
        constraintChecking: boolean;
        backupBeforeWrite: boolean;
    };
}
export interface ReferenceLibrarian extends LibrarianAgent {
    role: 'reference-librarian';
    researchCapabilities: {
        crossDatabaseQueries: boolean;
        complexJoinOptimization: boolean;
        semanticSearchSupport: boolean;
        knowledgeGraphTraversal: boolean;
    };
    analyticsFeatures: {
        queryPerformanceAnalysis: boolean;
        patternRecognition: boolean;
        dataQualityAssessment: boolean;
    };
}
export interface SpecialistAgent extends LibrarianAgent {
    role: 'specialist';
    expertiseArea: 'sql' | 'vector' | 'graph' | 'optimization' | 'security';
    advancedCapabilities: {
        algorithmicOptimization: boolean;
        distributedProcessing: boolean;
        realTimeAnalysis: boolean;
        machineLearningIntegration: boolean;
    };
}
export interface OrchestrationMetrics {
    throughput: {
        writesPerSecond: number;
        readsPerSecond: number;
        operationsPerSecond: number;
    };
    performance: {
        averageWriteTime: number;
        averageReadTime: number;
        p95WriteTime: number;
        p95ReadTime: number;
    };
    reliability: {
        writeSuccessRate: number;
        readSuccessRate: number;
        consistencyViolations: number;
    };
    resource: {
        agentUtilization: Record<string, number>;
        queueDepth: {
            writes: number;
            reads: number;
        };
        memoryUsage: number;
    };
    trends: {
        operationGrowthRate: number;
        errorTrends: Array<{
            date: Date;
            errorCount: number;
            errorTypes: Record<string, number>;
        }>;
    };
}
export interface AlertRule {
    id: string;
    name: string;
    condition: string;
    severity: 'info' | 'warning' | 'error' | 'critical';
    enabled: boolean;
    triggers: {
        threshold: number;
        duration: number;
        frequency: number;
    };
    actions: {
        notify: string[];
        escalate: boolean;
        autoRemediation?: string;
    };
}
export interface SystemHealth {
    overall: 'healthy' | 'warning' | 'critical';
    components: {
        writeOrchestrator: 'healthy' | 'degraded' | 'down';
        readOrchestrator: 'healthy' | 'degraded' | 'down';
        consistencyChecker: 'healthy' | 'degraded' | 'down';
        agentRegistry: 'healthy' | 'degraded' | 'down';
    };
    activeAlerts: AlertRule[];
    lastChecked: Date;
    uptime: number;
}
export interface DatabaseConnector {
    type: DataType;
    connectionString: string;
    credentials: {
        username: string;
        password: string;
        ssl?: boolean;
    };
    pooling: {
        minConnections: number;
        maxConnections: number;
        idleTimeout: number;
    };
    monitoring: {
        healthCheckQuery: string;
        timeoutMs: number;
        retryAttempts: number;
    };
}
export interface AgentDiscovery {
    /**
     * Register new librarian agent
     */
    registerAgent: (agent: LibrarianAgent) => Promise<void>;
    /**
     * Discover available agents by capability
     */
    discoverAgents: (requiredCapabilities: string[], dataType?: DataType) => Promise<LibrarianAgent[]>;
    /**
     * Health check for registered agents
     */
    healthCheck: (agentId: string) => Promise<{
        healthy: boolean;
        responseTime: number;
        lastSeen: Date;
    }>;
    /**
     * Load balancing for agent assignment
     */
    selectOptimalAgent: (candidates: LibrarianAgent[], operation: WriteOperation | ReadOperation) => Promise<LibrarianAgent>;
}
//# sourceMappingURL=types.d.ts.map