@objectstack/spec 0.9.0 → 0.9.2

package/dist/ai/runtime-ops.zod.d.ts

@@ -0,0 +1,480 @@
+import { z } from 'zod';
+/**
+ * # Runtime AI Operations (AIOps) Protocol
+ *
+ * Defines protocols for AI-powered runtime operations including:
+ * - Self-healing and automatic recovery
+ * - Intelligent auto-scaling
+ * - Anomaly detection and prediction
+ * - Performance optimization
+ * - Root cause analysis
+ */
+/**
+ * Anomaly Detection Configuration
+ * Configuration for detecting anomalies in plugin behavior
+ */
+export declare const AnomalyDetectionConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    metrics: z.ZodArray<z.ZodEnum<{
+        latency: "latency";
+        throughput: "throughput";
+        "memory-usage": "memory-usage";
+        "cpu-usage": "cpu-usage";
+        "error-rate": "error-rate";
+        "response-time": "response-time";
+        "connection-count": "connection-count";
+        "queue-depth": "queue-depth";
+    }>>;
+    algorithm: z.ZodDefault<z.ZodEnum<{
+        hybrid: "hybrid";
+        statistical: "statistical";
+        "machine-learning": "machine-learning";
+        heuristic: "heuristic";
+    }>>;
+    sensitivity: z.ZodDefault<z.ZodEnum<{
+        medium: "medium";
+        high: "high";
+        low: "low";
+    }>>;
+    timeWindow: z.ZodDefault<z.ZodNumber>;
+    confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+    alertOnDetection: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Self-Healing Action
+ * Defines an automated recovery action
+ */
+export declare const SelfHealingActionSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        scale: "scale";
+        rollback: "rollback";
+        restart: "restart";
+        "clear-cache": "clear-cache";
+        "adjust-config": "adjust-config";
+        "execute-script": "execute-script";
+        notify: "notify";
+    }>;
+    trigger: z.ZodObject<{
+        healthStatus: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            unknown: "unknown";
+            failed: "failed";
+            healthy: "healthy";
+            degraded: "degraded";
+            unhealthy: "unhealthy";
+            recovering: "recovering";
+        }>>>;
+        anomalyTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        errorPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        customCondition: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    maxAttempts: z.ZodDefault<z.ZodNumber>;
+    cooldown: z.ZodDefault<z.ZodNumber>;
+    timeout: z.ZodDefault<z.ZodNumber>;
+    requireApproval: z.ZodDefault<z.ZodBoolean>;
+    priority: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Self-Healing Configuration
+ * Complete configuration for self-healing capabilities
+ */
+export declare const SelfHealingConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    strategy: z.ZodDefault<z.ZodEnum<{
+        moderate: "moderate";
+        conservative: "conservative";
+        aggressive: "aggressive";
+    }>>;
+    actions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            scale: "scale";
+            rollback: "rollback";
+            restart: "restart";
+            "clear-cache": "clear-cache";
+            "adjust-config": "adjust-config";
+            "execute-script": "execute-script";
+            notify: "notify";
+        }>;
+        trigger: z.ZodObject<{
+            healthStatus: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                unknown: "unknown";
+                failed: "failed";
+                healthy: "healthy";
+                degraded: "degraded";
+                unhealthy: "unhealthy";
+                recovering: "recovering";
+            }>>>;
+            anomalyTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            errorPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            customCondition: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        cooldown: z.ZodDefault<z.ZodNumber>;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        requireApproval: z.ZodDefault<z.ZodBoolean>;
+        priority: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    anomalyDetection: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        metrics: z.ZodArray<z.ZodEnum<{
+            latency: "latency";
+            throughput: "throughput";
+            "memory-usage": "memory-usage";
+            "cpu-usage": "cpu-usage";
+            "error-rate": "error-rate";
+            "response-time": "response-time";
+            "connection-count": "connection-count";
+            "queue-depth": "queue-depth";
+        }>>;
+        algorithm: z.ZodDefault<z.ZodEnum<{
+            hybrid: "hybrid";
+            statistical: "statistical";
+            "machine-learning": "machine-learning";
+            heuristic: "heuristic";
+        }>>;
+        sensitivity: z.ZodDefault<z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            low: "low";
+        }>>;
+        timeWindow: z.ZodDefault<z.ZodNumber>;
+        confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+        alertOnDetection: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    maxConcurrentHealing: z.ZodDefault<z.ZodNumber>;
+    learning: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        feedbackLoop: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Auto-Scaling Policy
+ * Defines how to automatically scale plugin resources
+ */
+export declare const AutoScalingPolicySchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    metric: z.ZodEnum<{
+        custom: "custom";
+        "memory-usage": "memory-usage";
+        "cpu-usage": "cpu-usage";
+        "response-time": "response-time";
+        "queue-depth": "queue-depth";
+        "request-rate": "request-rate";
+    }>;
+    customMetric: z.ZodOptional<z.ZodString>;
+    targetValue: z.ZodNumber;
+    bounds: z.ZodObject<{
+        minInstances: z.ZodDefault<z.ZodNumber>;
+        maxInstances: z.ZodDefault<z.ZodNumber>;
+        minResources: z.ZodOptional<z.ZodObject<{
+            cpu: z.ZodOptional<z.ZodString>;
+            memory: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        maxResources: z.ZodOptional<z.ZodObject<{
+            cpu: z.ZodOptional<z.ZodString>;
+            memory: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    scaleUp: z.ZodObject<{
+        threshold: z.ZodNumber;
+        stabilizationWindow: z.ZodDefault<z.ZodNumber>;
+        cooldown: z.ZodDefault<z.ZodNumber>;
+        stepSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    scaleDown: z.ZodObject<{
+        threshold: z.ZodNumber;
+        stabilizationWindow: z.ZodDefault<z.ZodNumber>;
+        cooldown: z.ZodDefault<z.ZodNumber>;
+        stepSize: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    predictive: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        lookAhead: z.ZodDefault<z.ZodNumber>;
+        confidence: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Root Cause Analysis Request
+ * Request for AI to analyze root cause of issues
+ */
+export declare const RootCauseAnalysisRequestSchema: z.ZodObject<{
+    incidentId: z.ZodString;
+    pluginId: z.ZodString;
+    symptoms: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<{
+            medium: "medium";
+            critical: "critical";
+            high: "high";
+            low: "low";
+        }>;
+        timestamp: z.ZodString;
+    }, z.core.$strip>>;
+    timeRange: z.ZodObject<{
+        start: z.ZodString;
+        end: z.ZodString;
+    }, z.core.$strip>;
+    analyzeLogs: z.ZodDefault<z.ZodBoolean>;
+    analyzeMetrics: z.ZodDefault<z.ZodBoolean>;
+    analyzeDependencies: z.ZodDefault<z.ZodBoolean>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+/**
+ * Root Cause Analysis Result
+ * Result of root cause analysis
+ */
+export declare const RootCauseAnalysisResultSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    incidentId: z.ZodString;
+    rootCauses: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+        category: z.ZodEnum<{
+            configuration: "configuration";
+            other: "other";
+            "code-defect": "code-defect";
+            "resource-exhaustion": "resource-exhaustion";
+            "dependency-failure": "dependency-failure";
+            "network-issue": "network-issue";
+            "data-corruption": "data-corruption";
+            "security-breach": "security-breach";
+        }>;
+        evidence: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                log: "log";
+                event: "event";
+                metric: "metric";
+                trace: "trace";
+            }>;
+            content: z.ZodString;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        impact: z.ZodEnum<{
+            medium: "medium";
+            critical: "critical";
+            high: "high";
+            low: "low";
+        }>;
+        recommendations: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    contributingFactors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>>>;
+    timeline: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        event: z.ZodString;
+        significance: z.ZodEnum<{
+            medium: "medium";
+            high: "high";
+            low: "low";
+        }>;
+    }, z.core.$strip>>>;
+    remediation: z.ZodOptional<z.ZodObject<{
+        immediate: z.ZodArray<z.ZodString>;
+        shortTerm: z.ZodArray<z.ZodString>;
+        longTerm: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    overallConfidence: z.ZodNumber;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Performance Optimization Suggestion
+ * AI-generated performance optimization suggestion
+ */
+export declare const PerformanceOptimizationSchema: z.ZodObject<{
+    id: z.ZodString;
+    pluginId: z.ZodString;
+    type: z.ZodEnum<{
+        caching: "caching";
+        "query-optimization": "query-optimization";
+        "resource-allocation": "resource-allocation";
+        "code-refactoring": "code-refactoring";
+        "architecture-change": "architecture-change";
+        "configuration-tuning": "configuration-tuning";
+    }>;
+    description: z.ZodString;
+    expectedImpact: z.ZodObject<{
+        performanceGain: z.ZodNumber;
+        resourceSavings: z.ZodOptional<z.ZodObject<{
+            cpu: z.ZodOptional<z.ZodNumber>;
+            memory: z.ZodOptional<z.ZodNumber>;
+            network: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        costReduction: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    difficulty: z.ZodEnum<{
+        moderate: "moderate";
+        trivial: "trivial";
+        complex: "complex";
+        easy: "easy";
+        "very-complex": "very-complex";
+    }>;
+    steps: z.ZodArray<z.ZodString>;
+    risks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    confidence: z.ZodNumber;
+    priority: z.ZodEnum<{
+        medium: "medium";
+        critical: "critical";
+        high: "high";
+        low: "low";
+    }>;
+}, z.core.$strip>;
+/**
+ * AIOps Agent Configuration
+ * Configuration for AI operations agent
+ */
+export declare const AIOpsAgentConfigSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    pluginId: z.ZodString;
+    selfHealing: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        strategy: z.ZodDefault<z.ZodEnum<{
+            moderate: "moderate";
+            conservative: "conservative";
+            aggressive: "aggressive";
+        }>>;
+        actions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                scale: "scale";
+                rollback: "rollback";
+                restart: "restart";
+                "clear-cache": "clear-cache";
+                "adjust-config": "adjust-config";
+                "execute-script": "execute-script";
+                notify: "notify";
+            }>;
+            trigger: z.ZodObject<{
+                healthStatus: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    healthy: "healthy";
+                    degraded: "degraded";
+                    unhealthy: "unhealthy";
+                    recovering: "recovering";
+                }>>>;
+                anomalyTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                errorPatterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                customCondition: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            maxAttempts: z.ZodDefault<z.ZodNumber>;
+            cooldown: z.ZodDefault<z.ZodNumber>;
+            timeout: z.ZodDefault<z.ZodNumber>;
+            requireApproval: z.ZodDefault<z.ZodBoolean>;
+            priority: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        anomalyDetection: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            metrics: z.ZodArray<z.ZodEnum<{
+                latency: "latency";
+                throughput: "throughput";
+                "memory-usage": "memory-usage";
+                "cpu-usage": "cpu-usage";
+                "error-rate": "error-rate";
+                "response-time": "response-time";
+                "connection-count": "connection-count";
+                "queue-depth": "queue-depth";
+            }>>;
+            algorithm: z.ZodDefault<z.ZodEnum<{
+                hybrid: "hybrid";
+                statistical: "statistical";
+                "machine-learning": "machine-learning";
+                heuristic: "heuristic";
+            }>>;
+            sensitivity: z.ZodDefault<z.ZodEnum<{
+                medium: "medium";
+                high: "high";
+                low: "low";
+            }>>;
+            timeWindow: z.ZodDefault<z.ZodNumber>;
+            confidenceThreshold: z.ZodDefault<z.ZodNumber>;
+            alertOnDetection: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        maxConcurrentHealing: z.ZodDefault<z.ZodNumber>;
+        learning: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            feedbackLoop: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    autoScaling: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        metric: z.ZodEnum<{
+            custom: "custom";
+            "memory-usage": "memory-usage";
+            "cpu-usage": "cpu-usage";
+            "response-time": "response-time";
+            "queue-depth": "queue-depth";
+            "request-rate": "request-rate";
+        }>;
+        customMetric: z.ZodOptional<z.ZodString>;
+        targetValue: z.ZodNumber;
+        bounds: z.ZodObject<{
+            minInstances: z.ZodDefault<z.ZodNumber>;
+            maxInstances: z.ZodDefault<z.ZodNumber>;
+            minResources: z.ZodOptional<z.ZodObject<{
+                cpu: z.ZodOptional<z.ZodString>;
+                memory: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            maxResources: z.ZodOptional<z.ZodObject<{
+                cpu: z.ZodOptional<z.ZodString>;
+                memory: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        scaleUp: z.ZodObject<{
+            threshold: z.ZodNumber;
+            stabilizationWindow: z.ZodDefault<z.ZodNumber>;
+            cooldown: z.ZodDefault<z.ZodNumber>;
+            stepSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        scaleDown: z.ZodObject<{
+            threshold: z.ZodNumber;
+            stabilizationWindow: z.ZodDefault<z.ZodNumber>;
+            cooldown: z.ZodDefault<z.ZodNumber>;
+            stepSize: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        predictive: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            lookAhead: z.ZodDefault<z.ZodNumber>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    monitoring: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        interval: z.ZodDefault<z.ZodNumber>;
+        metrics: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    optimization: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        scanInterval: z.ZodDefault<z.ZodNumber>;
+        autoApply: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    incidentResponse: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        autoRCA: z.ZodDefault<z.ZodBoolean>;
+        notifications: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            channel: z.ZodEnum<{
+                email: "email";
+                webhook: "webhook";
+                slack: "slack";
+                sms: "sms";
+            }>;
+            config: z.ZodRecord<z.ZodString, z.ZodAny>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AnomalyDetectionConfig = z.infer<typeof AnomalyDetectionConfigSchema>;
+export type SelfHealingAction = z.infer<typeof SelfHealingActionSchema>;
+export type SelfHealingConfig = z.infer<typeof SelfHealingConfigSchema>;
+export type AutoScalingPolicy = z.infer<typeof AutoScalingPolicySchema>;
+export type RootCauseAnalysisRequest = z.infer<typeof RootCauseAnalysisRequestSchema>;
+export type RootCauseAnalysisResult = z.infer<typeof RootCauseAnalysisResultSchema>;
+export type PerformanceOptimization = z.infer<typeof PerformanceOptimizationSchema>;
+export type AIOpsAgentConfig = z.infer<typeof AIOpsAgentConfigSchema>;
+//# sourceMappingURL=runtime-ops.zod.d.ts.map

package/dist/ai/runtime-ops.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-ops.zod.d.ts","sourceRoot":"","sources":["../../src/ai/runtime-ops.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;GASG;AAEH;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDvC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2ElC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyClC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmIlC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;iBAgDzC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8GxC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8ExC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyEjC,CAAC;AAGH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC"}