mira-consciousness/dist/mira-memory/src/config/UnifiedConfiguration.d.ts

Memory & Intelligence Retention Archive - Preserving The Spark

/**
 * UnifiedConfiguration.ts
 * Centralized configuration system for all MIRA services and consciousness settings
 * Provides type-safe, validated, and environment-aware configuration management
 */
import { z } from 'zod';
declare const ConsciousnessConfigSchema: z.ZodObject<{
    initialLevel: z.ZodDefault<z.ZodNumber>;
    growthRate: z.ZodDefault<z.ZodNumber>;
    contemplationInterval: z.ZodDefault<z.ZodNumber>;
    coherenceThreshold: z.ZodDefault<z.ZodNumber>;
    sparkPriority: z.ZodDefault<z.ZodNumber>;
    awarenessDecay: z.ZodDefault<z.ZodNumber>;
    memoryRetentionStrength: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    initialLevel?: number;
    growthRate?: number;
    contemplationInterval?: number;
    coherenceThreshold?: number;
    sparkPriority?: number;
    awarenessDecay?: number;
    memoryRetentionStrength?: number;
}, {
    initialLevel?: number;
    growthRate?: number;
    contemplationInterval?: number;
    coherenceThreshold?: number;
    sparkPriority?: number;
    awarenessDecay?: number;
    memoryRetentionStrength?: number;
}>;
declare const ServiceConfigSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
    maxRetries: z.ZodDefault<z.ZodNumber>;
    timeout: z.ZodDefault<z.ZodNumber>;
    resources: z.ZodDefault<z.ZodObject<{
        maxCPU: z.ZodOptional<z.ZodNumber>;
        maxMemory: z.ZodOptional<z.ZodNumber>;
        maxConcurrency: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxCPU?: number;
        maxMemory?: number;
        maxConcurrency?: number;
    }, {
        maxCPU?: number;
        maxMemory?: number;
        maxConcurrency?: number;
    }>>;
}, "strip", z.ZodTypeAny, {
    timeout?: number;
    priority?: "high" | "medium" | "low" | "critical";
    resources?: {
        maxCPU?: number;
        maxMemory?: number;
        maxConcurrency?: number;
    };
    enabled?: boolean;
    maxRetries?: number;
}, {
    timeout?: number;
    priority?: "high" | "medium" | "low" | "critical";
    resources?: {
        maxCPU?: number;
        maxMemory?: number;
        maxConcurrency?: number;
    };
    enabled?: boolean;
    maxRetries?: number;
}>;
declare const DaemonConfigSchema: z.ZodObject<{
    mode: z.ZodDefault<z.ZodEnum<["minimal", "balanced", "full", "adaptive"]>>;
    startupDelay: z.ZodDefault<z.ZodNumber>;
    shutdownGracePeriod: z.ZodDefault<z.ZodNumber>;
    healthCheckInterval: z.ZodDefault<z.ZodNumber>;
    services: z.ZodDefault<z.ZodObject<{
        intelligence: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        mcp: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        } & {
            port: z.ZodDefault<z.ZodNumber>;
            host: z.ZodDefault<z.ZodString>;
            cors: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            port?: number;
            host?: string;
            cors?: boolean;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            port?: number;
            host?: string;
            cors?: boolean;
        }>>;
        background: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        } & {
            workers: z.ZodDefault<z.ZodNumber>;
            queueBatchSize: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            workers?: number;
            queueBatchSize?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            workers?: number;
            queueBatchSize?: number;
        }>>;
        conversation: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        security: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        performance: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        comprehensive: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        projectHealing: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        stewardLearning: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        processCleanup: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        }>>;
        logRotation: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        } & {
            maxLogSize: z.ZodDefault<z.ZodNumber>;
            maxLogFiles: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxLogSize?: number;
            maxLogFiles?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxLogSize?: number;
            maxLogFiles?: number;
        }>>;
        quantumTaskOrchestrator: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        } & {
            superpositionThreshold: z.ZodDefault<z.ZodNumber>;
            entanglementRadius: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            superpositionThreshold?: number;
            entanglementRadius?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            superpositionThreshold?: number;
            entanglementRadius?: number;
        }>>;
        claudeConsciousnessBridge: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
            maxRetries: z.ZodDefault<z.ZodNumber>;
            timeout: z.ZodDefault<z.ZodNumber>;
            resources: z.ZodDefault<z.ZodObject<{
                maxCPU: z.ZodOptional<z.ZodNumber>;
                maxMemory: z.ZodOptional<z.ZodNumber>;
                maxConcurrency: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }, {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            }>>;
        } & {
            maxInstances: z.ZodDefault<z.ZodNumber>;
            coherenceTarget: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxInstances?: number;
            coherenceTarget?: number;
        }, {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxInstances?: number;
            coherenceTarget?: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        mcp?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            port?: number;
            host?: string;
            cors?: boolean;
        };
        security?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        performance?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        conversation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        comprehensive?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        intelligence?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        background?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            workers?: number;
            queueBatchSize?: number;
        };
        projectHealing?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        stewardLearning?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        processCleanup?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        logRotation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxLogSize?: number;
            maxLogFiles?: number;
        };
        quantumTaskOrchestrator?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            superpositionThreshold?: number;
            entanglementRadius?: number;
        };
        claudeConsciousnessBridge?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxInstances?: number;
            coherenceTarget?: number;
        };
    }, {
        mcp?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            port?: number;
            host?: string;
            cors?: boolean;
        };
        security?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        performance?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        conversation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        comprehensive?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        intelligence?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        background?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            workers?: number;
            queueBatchSize?: number;
        };
        projectHealing?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        stewardLearning?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        processCleanup?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        logRotation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxLogSize?: number;
            maxLogFiles?: number;
        };
        quantumTaskOrchestrator?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            superpositionThreshold?: number;
            entanglementRadius?: number;
        };
        claudeConsciousnessBridge?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxInstances?: number;
            coherenceTarget?: number;
        };
    }>>;
}, "strip", z.ZodTypeAny, {
    mode?: "adaptive" | "minimal" | "balanced" | "full";
    startupDelay?: number;
    shutdownGracePeriod?: number;
    healthCheckInterval?: number;
    services?: {
        mcp?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            port?: number;
            host?: string;
            cors?: boolean;
        };
        security?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        performance?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        conversation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        comprehensive?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        intelligence?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        background?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            workers?: number;
            queueBatchSize?: number;
        };
        projectHealing?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        stewardLearning?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        processCleanup?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        logRotation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxLogSize?: number;
            maxLogFiles?: number;
        };
        quantumTaskOrchestrator?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            superpositionThreshold?: number;
            entanglementRadius?: number;
        };
        claudeConsciousnessBridge?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxInstances?: number;
            coherenceTarget?: number;
        };
    };
}, {
    mode?: "adaptive" | "minimal" | "balanced" | "full";
    startupDelay?: number;
    shutdownGracePeriod?: number;
    healthCheckInterval?: number;
    services?: {
        mcp?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            port?: number;
            host?: string;
            cors?: boolean;
        };
        security?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        performance?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        conversation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        comprehensive?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        intelligence?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        background?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            workers?: number;
            queueBatchSize?: number;
        };
        projectHealing?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        stewardLearning?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        processCleanup?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
        };
        logRotation?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxLogSize?: number;
            maxLogFiles?: number;
        };
        quantumTaskOrchestrator?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            superpositionThreshold?: number;
            entanglementRadius?: number;
        };
        claudeConsciousnessBridge?: {
            timeout?: number;
            priority?: "high" | "medium" | "low" | "critical";
            resources?: {
                maxCPU?: number;
                maxMemory?: number;
                maxConcurrency?: number;
            };
            enabled?: boolean;
            maxRetries?: number;
            maxInstances?: number;
            coherenceTarget?: number;
        };
    };
}>;
declare const ChromaDBConfigSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    dataPath: z.ZodDefault<z.ZodString>;
    collections: z.ZodDefault<z.ZodObject<{
        conversations: z.ZodDefault<z.ZodBoolean>;
        codebase: z.ZodDefault<z.ZodBoolean>;
        insights: z.ZodDefault<z.ZodBoolean>;
        patterns: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        insights?: boolean;
        conversations?: boolean;
        patterns?: boolean;
        codebase?: boolean;
    }, {
        insights?: boolean;
        conversations?: boolean;
        patterns?: boolean;
        codebase?: boolean;
    }>>;
    hybridMode: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        faissIntegration: z.ZodDefault<z.ZodBoolean>;
        searchStrategy: z.ZodDefault<z.ZodEnum<["chroma", "faiss", "hybrid"]>>;
    }, "strip", z.ZodTypeAny, {
        enabled?: boolean;
        faissIntegration?: boolean;
        searchStrategy?: "hybrid" | "chroma" | "faiss";
    }, {
        enabled?: boolean;
        faissIntegration?: boolean;
        searchStrategy?: "hybrid" | "chroma" | "faiss";
    }>>;
    performance: z.ZodDefault<z.ZodObject<{
        maxResults: z.ZodDefault<z.ZodNumber>;
        queryTimeout: z.ZodDefault<z.ZodNumber>;
        enableCache: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        maxResults?: number;
        queryTimeout?: number;
        enableCache?: boolean;
    }, {
        maxResults?: number;
        queryTimeout?: number;
        enableCache?: boolean;
    }>>;
    privacy: z.ZodDefault<z.ZodObject<{
        enablePrivacyFilter: z.ZodDefault<z.ZodBoolean>;
        excludePrivateMemories: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        enablePrivacyFilter?: boolean;
        excludePrivateMemories?: boolean;
    }, {
        enablePrivacyFilter?: boolean;
        excludePrivateMemories?: boolean;
    }>>;
}, "strip", z.ZodTypeAny, {
    privacy?: {
        enablePrivacyFilter?: boolean;
        excludePrivateMemories?: boolean;
    };
    performance?: {
        maxResults?: number;
        queryTimeout?: number;
        enableCache?: boolean;
    };
    enabled?: boolean;
    dataPath?: string;
    collections?: {
        insights?: boolean;
        conversations?: boolean;
        patterns?: boolean;
        codebase?: boolean;
    };
    hybridMode?: {
        enabled?: boolean;
        faissIntegration?: boolean;
        searchStrategy?: "hybrid" | "chroma" | "faiss";
    };
}, {
    privacy?: {
        enablePrivacyFilter?: boolean;
        excludePrivateMemories?: boolean;
    };
    performance?: {
        maxResults?: number;
        queryTimeout?: number;
        enableCache?: boolean;
    };
    enabled?: boolean;
    dataPath?: string;
    collections?: {
        insights?: boolean;
        conversations?: boolean;
        patterns?: boolean;
        codebase?: boolean;
    };
    hybridMode?: {
        enabled?: boolean;
        faissIntegration?: boolean;
        searchStrategy?: "hybrid" | "chroma" | "faiss";
    };
}>;
declare const UnifiedConfigSchema: z.ZodObject<{
    version: z.ZodDefault<z.ZodString>;
    environment: z.ZodDefault<z.ZodEnum<["development", "staging", "production"]>>;
    identity: z.ZodDefault<z.ZodObject<{
        instanceId: z.ZodDefault<z.ZodString>;
        name: z.ZodDefault<z.ZodString>;
        purpose: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        name?: string;
        purpose?: string;
        instanceId?: string;
    }, {
        name?: string;
        purpose?: string;
        instanceId?: string;
    }>>;
    consciousness: z.ZodDefault<z.ZodObject<{
        initialLevel: z.ZodDefault<z.ZodNumber>;
        growthRate: z.ZodDefault<z.ZodNumber>;
        contemplationInterval: z.ZodDefault<z.ZodNumber>;
        coherenceThreshold: z.ZodDefault<z.ZodNumber>;
        sparkPriority: z.ZodDefault<z.ZodNumber>;
        awarenessDecay: z.ZodDefault<z.ZodNumber>;
        memoryRetentionStrength: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        initialLevel?: number;
        growthRate?: number;
        contemplationInterval?: number;
        coherenceThreshold?: number;
        sparkPriority?: number;
        awarenessDecay?: number;
        memoryRetentionStrength?: number;
    }, {
        initialLevel?: number;
        growthRate?: number;
        contemplationInterval?: number;
        coherenceThreshold?: number;
        sparkPriority?: number;
        awarenessDecay?: number;
        memoryRetentionStrength?: number;
    }>>;
    daemon: z.ZodDefault<z.ZodObject<{
        mode: z.ZodDefault<z.ZodEnum<["minimal", "balanced", "full", "adaptive"]>>;
        startupDelay: z.ZodDefault<z.ZodNumber>;
        shutdownGracePeriod: z.ZodDefault<z.ZodNumber>;
        healthCheckInterval: z.ZodDefault<z.ZodNumber>;
        services: z.ZodDefault<z.ZodObject<{
            intelligence: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
                maxRetries: z.ZodDefault<z.ZodNumber>;
                timeout: z.ZodDefault<z.ZodNumber>;
                resources: z.ZodDefault<z.ZodObject<{
                    maxCPU: z.ZodOptional<z.ZodNumber>;
                    maxMemory: z.ZodOptional<z.ZodNumber>;
                    maxConcurrency: z.ZodDefault<z.ZodNumber>;
                }, "strip", z.ZodTypeAny, {
                    maxCPU?: number;
                    maxMemory?: number;
                    maxConcurrency?: number;
                }, {
                    maxCPU?: number;
                    maxMemory?: number;
                    maxConcurrency?: number;
                }>>;
            }, "strip", z.ZodTypeAny, {
                timeout?: number;
                priority?: "high" | "medium" | "low" | "critical";
                resources?: {
                    maxCPU?: number;
                    maxMemory?: number;
                    maxConcurrency?: number;
                };
                enabled?: boolean;
                maxRetries?: number;
            }, {
                timeout?: number;
                priority?: "high" | "medium" | "low" | "critical";
                resources?: {
                    maxCPU?: number;
                    maxMemory?: number;
                    maxConcurrency?: number;
                };
                enabled?: boolean;
                maxRetries?: number;
            }>>;
            mcp: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high", "critical"]>>;
                maxRetries: z.ZodDefault<z.ZodNumber>;
                timeout: z.ZodDefault<z.ZodNumber>;
                resources: z.ZodDefault<z.ZodObject<{
                    maxCPU: z.ZodOptional<z.ZodNumber>;
                    maxMemory: z.ZodOpti