claritykit-svelte
Version:
A comprehensive Svelte component library focused on accessibility, ADHD-optimized design, developer experience, and full SSR compatibility
464 lines • 13.3 kB
TypeScript
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