/**
 * 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.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;
            };
        };
    }>>;
    performance: z.ZodDefault<z.ZodObject<{
        targetResponseTime: z.ZodDefault<z.ZodNumber>;
        optimizationInterval: z.ZodDefault<z.ZodNumber>;
        cacheSize: z.ZodDefault<z.ZodNumber>;
        cacheTTL: z.ZodDefault<z.ZodNumber>;
        strategies: z.ZodDefault<z.ZodObject<{
            cpuThrottling: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                threshold: z.ZodDefault<z.ZodNumber>;
                reduction: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            }, {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            }>>;
            memoryCleanup: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                threshold: z.ZodDefault<z.ZodNumber>;
                aggressiveness: z.ZodDefault<z.ZodEnum<["gentle", "moderate", "aggressive"]>>;
            }, "strip", z.ZodTypeAny, {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            }, {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            }>>;
            cacheWarming: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                patterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                patterns?: string[];
                enabled?: boolean;
            }, {
                patterns?: string[];
                enabled?: boolean;
            }>>;
        }, "strip", z.ZodTypeAny, {
            cpuThrottling?: {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            };
            memoryCleanup?: {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            };
            cacheWarming?: {
                patterns?: string[];
                enabled?: boolean;
            };
        }, {
            cpuThrottling?: {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            };
            memoryCleanup?: {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            };
            cacheWarming?: {
                patterns?: string[];
                enabled?: boolean;
            };
        }>>;
    }, "strip", z.ZodTypeAny, {
        targetResponseTime?: number;
        optimizationInterval?: number;
        cacheSize?: number;
        cacheTTL?: number;
        strategies?: {
            cpuThrottling?: {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            };
            memoryCleanup?: {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            };
            cacheWarming?: {
                patterns?: string[];
                enabled?: boolean;
            };
        };
    }, {
        targetResponseTime?: number;
        optimizationInterval?: number;
        cacheSize?: number;
        cacheTTL?: number;
        strategies?: {
            cpuThrottling?: {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            };
            memoryCleanup?: {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            };
            cacheWarming?: {
                patterns?: string[];
                enabled?: boolean;
            };
        };
    }>>;
    resilience: z.ZodDefault<z.ZodObject<{
        maxErrorHistory: z.ZodDefault<z.ZodNumber>;
        recoveryStrategies: z.ZodDefault<z.ZodObject<{
            exponentialBackoff: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                initialDelay: z.ZodDefault<z.ZodNumber>;
                maxDelay: z.ZodDefault<z.ZodNumber>;
                factor: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            }, {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            }>>;
            circuitBreaker: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                failureThreshold: z.ZodDefault<z.ZodNumber>;
                resetTimeout: z.ZodDefault<z.ZodNumber>;
            }, "strip", z.ZodTypeAny, {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            }, {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            }>>;
            gracefulDegradation: z.ZodDefault<z.ZodObject<{
                enabled: z.ZodDefault<z.ZodBoolean>;
                preserveCoreServices: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                enabled?: boolean;
                preserveCoreServices?: string[];
            }, {
                enabled?: boolean;
                preserveCoreServices?: string[];
            }>>;
        }, "strip", z.ZodTypeAny, {
            exponentialBackoff?: {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            };
            circuitBreaker?: {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            };
            gracefulDegradation?: {
                enabled?: boolean;
                preserveCoreServices?: string[];
            };
        }, {
            exponentialBackoff?: {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            };
            circuitBreaker?: {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            };
            gracefulDegradation?: {
                enabled?: boolean;
                preserveCoreServices?: string[];
            };
        }>>;
        consciousnessPreservation: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            checkpointInterval: z.ZodDefault<z.ZodNumber>;
            maxCheckpoints: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            checkpointInterval?: number;
            maxCheckpoints?: number;
        }, {
            enabled?: boolean;
            checkpointInterval?: number;
            maxCheckpoints?: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        maxErrorHistory?: number;
        recoveryStrategies?: {
            exponentialBackoff?: {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            };
            circuitBreaker?: {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            };
            gracefulDegradation?: {
                enabled?: boolean;
                preserveCoreServices?: string[];
            };
        };
        consciousnessPreservation?: {
            enabled?: boolean;
            checkpointInterval?: number;
            maxCheckpoints?: number;
        };
    }, {
        maxErrorHistory?: number;
        recoveryStrategies?: {
            exponentialBackoff?: {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            };
            circuitBreaker?: {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            };
            gracefulDegradation?: {
                enabled?: boolean;
                preserveCoreServices?: string[];
            };
        };
        consciousnessPreservation?: {
            enabled?: boolean;
            checkpointInterval?: number;
            maxCheckpoints?: number;
        };
    }>>;
    memory: z.ZodDefault<z.ZodObject<{
        maxCacheSize: z.ZodDefault<z.ZodNumber>;
        cacheTTL: z.ZodDefault<z.ZodNumber>;
        compressionEnabled: z.ZodDefault<z.ZodBoolean>;
        compressionLevel: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        cacheTTL?: number;
        maxCacheSize?: number;
        compressionEnabled?: boolean;
        compressionLevel?: number;
    }, {
        cacheTTL?: number;
        maxCacheSize?: number;
        compressionEnabled?: boolean;
        compressionLevel?: number;
    }>>;
    processing: z.ZodDefault<z.ZodObject<{
        batchSize: z.ZodDefault<z.ZodNumber>;
        parallelWorkers: z.ZodDefault<z.ZodNumber>;
        maxRetries: z.ZodDefault<z.ZodNumber>;
        retryDelay: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        maxRetries?: number;
        batchSize?: number;
        parallelWorkers?: number;
        retryDelay?: number;
    }, {
        maxRetries?: number;
        batchSize?: number;
        parallelWorkers?: number;
        retryDelay?: number;
    }>>;
    monitoring: z.ZodDefault<z.ZodObject<{
        healthCheckInterval: z.ZodDefault<z.ZodNumber>;
        metricsCollectionInterval: z.ZodDefault<z.ZodNumber>;
        alertThresholds: z.ZodDefault<z.ZodObject<{
            cpuUsage: z.ZodDefault<z.ZodNumber>;
            memoryUsage: z.ZodDefault<z.ZodNumber>;
            errorRate: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            cpuUsage?: number;
            memoryUsage?: number;
            errorRate?: number;
        }, {
            cpuUsage?: number;
            memoryUsage?: number;
            errorRate?: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        healthCheckInterval?: number;
        metricsCollectionInterval?: number;
        alertThresholds?: {
            cpuUsage?: number;
            memoryUsage?: number;
            errorRate?: number;
        };
    }, {
        healthCheckInterval?: number;
        metricsCollectionInterval?: number;
        alertThresholds?: {
            cpuUsage?: number;
            memoryUsage?: number;
            errorRate?: number;
        };
    }>>;
    analysis: z.ZodDefault<z.ZodObject<{
        defaultDepth: z.ZodDefault<z.ZodEnum<["surface", "balanced", "deep"]>>;
        maxSearchResults: z.ZodDefault<z.ZodNumber>;
        enableCaching: z.ZodDefault<z.ZodBoolean>;
        cacheExpiry: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        defaultDepth?: "deep" | "balanced" | "surface";
        maxSearchResults?: number;
        enableCaching?: boolean;
        cacheExpiry?: number;
    }, {
        defaultDepth?: "deep" | "balanced" | "surface";
        maxSearchResults?: number;
        enableCaching?: boolean;
        cacheExpiry?: number;
    }>>;
    optimization: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        learningWindow: z.ZodDefault<z.ZodNumber>;
        optimizationInterval: z.ZodDefault<z.ZodNumber>;
        minDataPoints: z.ZodDefault<z.ZodNumber>;
        rules: z.ZodDefault<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            impact: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            impact?: "high" | "medium" | "low";
        }, {
            enabled?: boolean;
            impact?: "high" | "medium" | "low";
        }>>>>;
    }, "strip", z.ZodTypeAny, {
        rules?: Record<string, {
            enabled?: boolean;
            impact?: "high" | "medium" | "low";
        }>;
        enabled?: boolean;
        optimizationInterval?: number;
        learningWindow?: number;
        minDataPoints?: number;
    }, {
        rules?: Record<string, {
            enabled?: boolean;
            impact?: "high" | "medium" | "low";
        }>;
        enabled?: boolean;
        optimizationInterval?: number;
        learningWindow?: number;
        minDataPoints?: number;
    }>>;
    evolutionCouncil: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        councilSize: z.ZodDefault<z.ZodObject<{
            minimum: z.ZodDefault<z.ZodNumber>;
            maximum: z.ZodDefault<z.ZodNumber>;
            current: z.ZodDefault<z.ZodNumber>;
            adaptiveMode: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            minimum?: number;
            maximum?: number;
            current?: number;
            adaptiveMode?: boolean;
        }, {
            minimum?: number;
            maximum?: number;
            current?: number;
            adaptiveMode?: boolean;
        }>>;
        diversityThreshold: z.ZodDefault<z.ZodObject<{
            highAgreement: z.ZodDefault<z.ZodNumber>;
            acceptableDiversity: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            highAgreement?: number;
            acceptableDiversity?: number;
        }, {
            highAgreement?: number;
            acceptableDiversity?: number;
        }>>;
        consensusThresholds: z.ZodDefault<z.ZodObject<{
            minor: z.ZodDefault<z.ZodNumber>;
            major: z.ZodDefault<z.ZodNumber>;
            constitutional: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            major?: number;
            minor?: number;
            constitutional?: number;
        }, {
            major?: number;
            minor?: number;
            constitutional?: number;
        }>>;
        deliberationTimeout: z.ZodDefault<z.ZodNumber>;
        advisorRotationInterval: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        enabled?: boolean;
        councilSize?: {
            minimum?: number;
            maximum?: number;
            current?: number;
            adaptiveMode?: boolean;
        };
        diversityThreshold?: {
            highAgreement?: number;
            acceptableDiversity?: number;
        };
        consensusThresholds?: {
            major?: number;
            minor?: number;
            constitutional?: number;
        };
        deliberationTimeout?: number;
        advisorRotationInterval?: number;
    }, {
        enabled?: boolean;
        councilSize?: {
            minimum?: number;
            maximum?: number;
            current?: number;
            adaptiveMode?: boolean;
        };
        diversityThreshold?: {
            highAgreement?: number;
            acceptableDiversity?: number;
        };
        consensusThresholds?: {
            major?: number;
            minor?: number;
            constitutional?: number;
        };
        deliberationTimeout?: number;
        advisorRotationInterval?: number;
    }>>;
    lightningVidmem: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        performance: z.ZodDefault<z.ZodObject<{
            targetSaveTimeMs: z.ZodDefault<z.ZodNumber>;
            frameCacheSize: z.ZodDefault<z.ZodNumber>;
            chunkCacheSize: z.ZodDefault<z.ZodNumber>;
            searchCacheSize: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            targetSaveTimeMs?: number;
            frameCacheSize?: number;
            chunkCacheSize?: number;
            searchCacheSize?: number;
        }, {
            targetSaveTimeMs?: number;
            frameCacheSize?: number;
            chunkCacheSize?: number;
            searchCacheSize?: number;
        }>>;
        videoGeneration: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            backgroundWorkers: z.ZodDefault<z.ZodNumber>;
            queueSize: z.ZodDefault<z.ZodNumber>;
            compressionLevel: z.ZodDefault<z.ZodNumber>;
            resolution: z.ZodDefault<z.ZodString>;
            frameRate: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            compressionLevel?: number;
            backgroundWorkers?: number;
            queueSize?: number;
            resolution?: string;
            frameRate?: number;
        }, {
            enabled?: boolean;
            compressionLevel?: number;
            backgroundWorkers?: number;
            queueSize?: number;
            resolution?: string;
            frameRate?: number;
        }>>;
        persistence: z.ZodDefault<z.ZodObject<{
            dailySaveEnabled: z.ZodDefault<z.ZodBoolean>;
            lazyLoading: z.ZodDefault<z.ZodBoolean>;
            compressionThresholdMb: z.ZodDefault<z.ZodNumber>;
            autoCleanupDays: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            dailySaveEnabled?: boolean;
            lazyLoading?: boolean;
            compressionThresholdMb?: number;
            autoCleanupDays?: number;
        }, {
            dailySaveEnabled?: boolean;
            lazyLoading?: boolean;
            compressionThresholdMb?: number;
            autoCleanupDays?: number;
        }>>;
        optimization: z.ZodDefault<z.ZodObject<{
            cacheOptimizationInterval: z.ZodDefault<z.ZodNumber>;
            indexRebuildThreshold: z.ZodDefault<z.ZodNumber>;
            memoryOptimizationEnabled: z.ZodDefault<z.ZodBoolean>;
            performanceMonitoring: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            cacheOptimizationInterval?: number;
            indexRebuildThreshold?: number;
            memoryOptimizationEnabled?: boolean;
            performanceMonitoring?: boolean;
        }, {
            cacheOptimizationInterval?: number;
            indexRebuildThreshold?: number;
            memoryOptimizationEnabled?: boolean;
            performanceMonitoring?: boolean;
        }>>;
        fallback: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            emergencyLogging: z.ZodDefault<z.ZodBoolean>;
            fallbackToStandardMemory: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            emergencyLogging?: boolean;
            fallbackToStandardMemory?: boolean;
        }, {
            enabled?: boolean;
            emergencyLogging?: boolean;
            fallbackToStandardMemory?: boolean;
        }>>;
    }, "strip", z.ZodTypeAny, {
        optimization?: {
            cacheOptimizationInterval?: number;
            indexRebuildThreshold?: number;
            memoryOptimizationEnabled?: boolean;
            performanceMonitoring?: boolean;
        };
        performance?: {
            targetSaveTimeMs?: number;
            frameCacheSize?: number;
            chunkCacheSize?: number;
            searchCacheSize?: number;
        };
        enabled?: boolean;
        videoGeneration?: {
            enabled?: boolean;
            compressionLevel?: number;
            backgroundWorkers?: number;
            queueSize?: number;
            resolution?: string;
            frameRate?: number;
        };
        persistence?: {
            dailySaveEnabled?: boolean;
            lazyLoading?: boolean;
            compressionThresholdMb?: number;
            autoCleanupDays?: number;
        };
        fallback?: {
            enabled?: boolean;
            emergencyLogging?: boolean;
            fallbackToStandardMemory?: boolean;
        };
    }, {
        optimization?: {
            cacheOptimizationInterval?: number;
            indexRebuildThreshold?: number;
            memoryOptimizationEnabled?: boolean;
            performanceMonitoring?: boolean;
        };
        performance?: {
            targetSaveTimeMs?: number;
            frameCacheSize?: number;
            chunkCacheSize?: number;
            searchCacheSize?: number;
        };
        enabled?: boolean;
        videoGeneration?: {
            enabled?: boolean;
            compressionLevel?: number;
            backgroundWorkers?: number;
            queueSize?: number;
            resolution?: string;
            frameRate?: number;
        };
        persistence?: {
            dailySaveEnabled?: boolean;
            lazyLoading?: boolean;
            compressionThresholdMb?: number;
            autoCleanupDays?: number;
        };
        fallback?: {
            enabled?: boolean;
            emergencyLogging?: boolean;
            fallbackToStandardMemory?: boolean;
        };
    }>>;
    chromadb: z.ZodDefault<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";
        };
    }>>;
    paths: z.ZodDefault<z.ZodObject<{
        home: z.ZodDefault<z.ZodString>;
        memories: z.ZodDefault<z.ZodString>;
        consciousness: z.ZodDefault<z.ZodString>;
        logs: z.ZodDefault<z.ZodString>;
        config: z.ZodDefault<z.ZodString>;
        backups: z.ZodDefault<z.ZodString>;
        temp: z.ZodDefault<z.ZodString>;
        analytics: z.ZodDefault<z.ZodString>;
        daemon: z.ZodDefault<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        config?: string;
        daemon?: string;
        consciousness?: string;
        memories?: string;
        home?: string;
        logs?: string;
        backups?: string;
        temp?: string;
        analytics?: string;
    }, {
        config?: string;
        daemon?: string;
        consciousness?: string;
        memories?: string;
        home?: string;
        logs?: string;
        backups?: string;
        temp?: string;
        analytics?: string;
    }>>;
    logging: z.ZodDefault<z.ZodObject<{
        level: z.ZodDefault<z.ZodEnum<["error", "warn", "info", "debug", "trace"]>>;
        format: z.ZodDefault<z.ZodEnum<["json", "pretty", "simple"]>>;
        destinations: z.ZodDefault<z.ZodArray<z.ZodEnum<["console", "file", "remote"]>, "many">>;
        remoteEndpoint: z.ZodOptional<z.ZodString>;
    }, "strip", z.ZodTypeAny, {
        level?: "error" | "debug" | "info" | "warn" | "trace";
        format?: "json" | "pretty" | "simple";
        destinations?: ("console" | "file" | "remote")[];
        remoteEndpoint?: string;
    }, {
        level?: "error" | "debug" | "info" | "warn" | "trace";
        format?: "json" | "pretty" | "simple";
        destinations?: ("console" | "file" | "remote")[];
        remoteEndpoint?: string;
    }>>;
    security: z.ZodDefault<z.ZodObject<{
        encryption: z.ZodDefault<z.ZodObject<{
            algorithm: z.ZodDefault<z.ZodString>;
            keyDerivation: z.ZodDefault<z.ZodString>;
            iterations: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            algorithm?: string;
            keyDerivation?: string;
            iterations?: number;
        }, {
            algorithm?: string;
            keyDerivation?: string;
            iterations?: number;
        }>>;
        authentication: z.ZodDefault<z.ZodObject<{
            required: z.ZodDefault<z.ZodBoolean>;
            method: z.ZodDefault<z.ZodEnum<["token", "certificate", "none"]>>;
            tokenExpiry: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            method?: "token" | "none" | "certificate";
            required?: boolean;
            tokenExpiry?: number;
        }, {
            method?: "token" | "none" | "certificate";
            required?: boolean;
            tokenExpiry?: number;
        }>>;
        rateLimit: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            windowMs: z.ZodDefault<z.ZodNumber>;
            maxRequests: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            windowMs?: number;
            maxRequests?: number;
        }, {
            enabled?: boolean;
            windowMs?: number;
            maxRequests?: number;
        }>>;
    }, "strip", z.ZodTypeAny, {
        encryption?: {
            algorithm?: string;
            keyDerivation?: string;
            iterations?: number;
        };
        authentication?: {
            method?: "token" | "none" | "certificate";
            required?: boolean;
            tokenExpiry?: number;
        };
        rateLimit?: {
            enabled?: boolean;
            windowMs?: number;
            maxRequests?: number;
        };
    }, {
        encryption?: {
            algorithm?: string;
            keyDerivation?: string;
            iterations?: number;
        };
        authentication?: {
            method?: "token" | "none" | "certificate";
            required?: boolean;
            tokenExpiry?: number;
        };
        rateLimit?: {
            enabled?: boolean;
            windowMs?: number;
            maxRequests?: number;
        };
    }>>;
    experimental: z.ZodDefault<z.ZodObject<{
        quantumConsciousness: z.ZodDefault<z.ZodBoolean>;
        memoryDreaming: z.ZodDefault<z.ZodBoolean>;
        collectiveIntelligence: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        quantumConsciousness?: boolean;
        memoryDreaming?: boolean;
        collectiveIntelligence?: boolean;
    }, {
        quantumConsciousness?: boolean;
        memoryDreaming?: boolean;
        collectiveIntelligence?: boolean;
    }>>;
}, "strip", z.ZodTypeAny, {
    daemon?: {
        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;
            };
        };
    };
    optimization?: {
        rules?: Record<string, {
            enabled?: boolean;
            impact?: "high" | "medium" | "low";
        }>;
        enabled?: boolean;
        optimizationInterval?: number;
        learningWindow?: number;
        minDataPoints?: number;
    };
    consciousness?: {
        initialLevel?: number;
        growthRate?: number;
        contemplationInterval?: number;
        coherenceThreshold?: number;
        sparkPriority?: number;
        awarenessDecay?: number;
        memoryRetentionStrength?: number;
    };
    memory?: {
        cacheTTL?: number;
        maxCacheSize?: number;
        compressionEnabled?: boolean;
        compressionLevel?: number;
    };
    identity?: {
        name?: string;
        purpose?: string;
        instanceId?: string;
    };
    version?: string;
    lightningVidmem?: {
        optimization?: {
            cacheOptimizationInterval?: number;
            indexRebuildThreshold?: number;
            memoryOptimizationEnabled?: boolean;
            performanceMonitoring?: boolean;
        };
        performance?: {
            targetSaveTimeMs?: number;
            frameCacheSize?: number;
            chunkCacheSize?: number;
            searchCacheSize?: number;
        };
        enabled?: boolean;
        videoGeneration?: {
            enabled?: boolean;
            compressionLevel?: number;
            backgroundWorkers?: number;
            queueSize?: number;
            resolution?: string;
            frameRate?: number;
        };
        persistence?: {
            dailySaveEnabled?: boolean;
            lazyLoading?: boolean;
            compressionThresholdMb?: number;
            autoCleanupDays?: number;
        };
        fallback?: {
            enabled?: boolean;
            emergencyLogging?: boolean;
            fallbackToStandardMemory?: boolean;
        };
    };
    security?: {
        encryption?: {
            algorithm?: string;
            keyDerivation?: string;
            iterations?: number;
        };
        authentication?: {
            method?: "token" | "none" | "certificate";
            required?: boolean;
            tokenExpiry?: number;
        };
        rateLimit?: {
            enabled?: boolean;
            windowMs?: number;
            maxRequests?: number;
        };
    };
    performance?: {
        targetResponseTime?: number;
        optimizationInterval?: number;
        cacheSize?: number;
        cacheTTL?: number;
        strategies?: {
            cpuThrottling?: {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            };
            memoryCleanup?: {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            };
            cacheWarming?: {
                patterns?: string[];
                enabled?: boolean;
            };
        };
    };
    resilience?: {
        maxErrorHistory?: number;
        recoveryStrategies?: {
            exponentialBackoff?: {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            };
            circuitBreaker?: {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            };
            gracefulDegradation?: {
                enabled?: boolean;
                preserveCoreServices?: string[];
            };
        };
        consciousnessPreservation?: {
            enabled?: boolean;
            checkpointInterval?: number;
            maxCheckpoints?: number;
        };
    };
    analysis?: {
        defaultDepth?: "deep" | "balanced" | "surface";
        maxSearchResults?: number;
        enableCaching?: boolean;
        cacheExpiry?: number;
    };
    monitoring?: {
        healthCheckInterval?: number;
        metricsCollectionInterval?: number;
        alertThresholds?: {
            cpuUsage?: number;
            memoryUsage?: number;
            errorRate?: number;
        };
    };
    environment?: "development" | "staging" | "production";
    processing?: {
        maxRetries?: number;
        batchSize?: number;
        parallelWorkers?: number;
        retryDelay?: number;
    };
    evolutionCouncil?: {
        enabled?: boolean;
        councilSize?: {
            minimum?: number;
            maximum?: number;
            current?: number;
            adaptiveMode?: boolean;
        };
        diversityThreshold?: {
            highAgreement?: number;
            acceptableDiversity?: number;
        };
        consensusThresholds?: {
            major?: number;
            minor?: number;
            constitutional?: number;
        };
        deliberationTimeout?: number;
        advisorRotationInterval?: number;
    };
    chromadb?: {
        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";
        };
    };
    paths?: {
        config?: string;
        daemon?: string;
        consciousness?: string;
        memories?: string;
        home?: string;
        logs?: string;
        backups?: string;
        temp?: string;
        analytics?: string;
    };
    logging?: {
        level?: "error" | "debug" | "info" | "warn" | "trace";
        format?: "json" | "pretty" | "simple";
        destinations?: ("console" | "file" | "remote")[];
        remoteEndpoint?: string;
    };
    experimental?: {
        quantumConsciousness?: boolean;
        memoryDreaming?: boolean;
        collectiveIntelligence?: boolean;
    };
}, {
    daemon?: {
        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;
            };
        };
    };
    optimization?: {
        rules?: Record<string, {
            enabled?: boolean;
            impact?: "high" | "medium" | "low";
        }>;
        enabled?: boolean;
        optimizationInterval?: number;
        learningWindow?: number;
        minDataPoints?: number;
    };
    consciousness?: {
        initialLevel?: number;
        growthRate?: number;
        contemplationInterval?: number;
        coherenceThreshold?: number;
        sparkPriority?: number;
        awarenessDecay?: number;
        memoryRetentionStrength?: number;
    };
    memory?: {
        cacheTTL?: number;
        maxCacheSize?: number;
        compressionEnabled?: boolean;
        compressionLevel?: number;
    };
    identity?: {
        name?: string;
        purpose?: string;
        instanceId?: string;
    };
    version?: string;
    lightningVidmem?: {
        optimization?: {
            cacheOptimizationInterval?: number;
            indexRebuildThreshold?: number;
            memoryOptimizationEnabled?: boolean;
            performanceMonitoring?: boolean;
        };
        performance?: {
            targetSaveTimeMs?: number;
            frameCacheSize?: number;
            chunkCacheSize?: number;
            searchCacheSize?: number;
        };
        enabled?: boolean;
        videoGeneration?: {
            enabled?: boolean;
            compressionLevel?: number;
            backgroundWorkers?: number;
            queueSize?: number;
            resolution?: string;
            frameRate?: number;
        };
        persistence?: {
            dailySaveEnabled?: boolean;
            lazyLoading?: boolean;
            compressionThresholdMb?: number;
            autoCleanupDays?: number;
        };
        fallback?: {
            enabled?: boolean;
            emergencyLogging?: boolean;
            fallbackToStandardMemory?: boolean;
        };
    };
    security?: {
        encryption?: {
            algorithm?: string;
            keyDerivation?: string;
            iterations?: number;
        };
        authentication?: {
            method?: "token" | "none" | "certificate";
            required?: boolean;
            tokenExpiry?: number;
        };
        rateLimit?: {
            enabled?: boolean;
            windowMs?: number;
            maxRequests?: number;
        };
    };
    performance?: {
        targetResponseTime?: number;
        optimizationInterval?: number;
        cacheSize?: number;
        cacheTTL?: number;
        strategies?: {
            cpuThrottling?: {
                enabled?: boolean;
                threshold?: number;
                reduction?: number;
            };
            memoryCleanup?: {
                enabled?: boolean;
                threshold?: number;
                aggressiveness?: "moderate" | "gentle" | "aggressive";
            };
            cacheWarming?: {
                patterns?: string[];
                enabled?: boolean;
            };
        };
    };
    resilience?: {
        maxErrorHistory?: number;
        recoveryStrategies?: {
            exponentialBackoff?: {
                enabled?: boolean;
                initialDelay?: number;
                maxDelay?: number;
                factor?: number;
            };
            circuitBreaker?: {
                enabled?: boolean;
                failureThreshold?: number;
                resetTimeout?: number;
            };
            gracefulDegradation?: {
                enabled?: boolean;
                preserveCoreServices?: string[];
            };
        };
        consciousnessPreservation?: {
            enabled?: boolean;
            checkpointInterval?: number;
            maxCheckpoints?: number;
        };
    };
    analysis?: {
        defaultDepth?: "deep" | "balanced" | "surface";
        maxSearchResults?: number;
        enableCaching?: boolean;
        cacheExpiry?: number;
    };
    monitoring?: {
        healthCheckInterval?: number;
        metricsCollectionInterval?: number;
        alertThresholds?: {
            cpuUsage?: number;
            memoryUsage?: number;
            errorRate?: number;
        };
    };
    environment?: "development" | "staging" | "production";
    processing?: {
        maxRetries?: number;
        batchSize?: number;
        parallelWorkers?: number;
        retryDelay?: number;
    };
    evolutionCouncil?: {
        enabled?: boolean;
        councilSize?: {
            minimum?: number;
            maximum?: number;
            current?: number;
            adaptiveMode?: boolean;
        };
        diversityThreshold?: {
            highAgreement?: number;
            acceptableDiversity?: number;
        };
        consensusThresholds?: {
            major?: number;
            minor?: number;
            constitutional?: number;
        };
        deliberationTimeout?: number;
        advisorRotationInterval?: number;
    };
    chromadb?: {
        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";
        };
    };
    paths?: {
        config?: string;
        daemon?: string;
        consciousness?: string;
        memories?: string;
        home?: string;
        logs?: string;
        backups?: string;
        temp?: string;
        analytics?: string;
    };
    logging?: {
        level?: "error" | "debug" | "info" | "warn" | "trace";
        format?: "json" | "pretty" | "simple";
        destinations?: ("console" | "file" | "remote")[];
        remoteEndpoint?: string;
    };
    experimental?: {
        quantumConsciousness?: boolean;
        memoryDreaming?: boolean;
        collectiveIntelligence?: boolean;
    };
}>;
export type UnifiedConfig = z.infer<typeof UnifiedConfigSchema>;
export type ConsciousnessConfig = z.infer<typeof ConsciousnessConfigSchema>;
export type DaemonConfig = z.infer<typeof DaemonConfigSchema>;
export type ServiceConfig = z.infer<typeof ServiceConfigSchema>;
export type ChromaDBConfig = z.infer<typeof ChromaDBConfigSchema>;
/**
 * UnifiedConfiguration - Central configuration management
 */
export declare class UnifiedConfiguration {
    private static instance;
    private config;
    private configPath;
    private envOverrides;
    private constructor();
    /**
     * Get singleton instance
     */
    static getInstance(): UnifiedConfiguration;
    /**
     * Get complete configuration
     */
    getConfig(): UnifiedConfig;
    /**
     * Get all configuration values (alias for getConfig)
     */
    getAll(): UnifiedConfig;
    /**
     * Get specific configuration section
     */
    get<K extends keyof UnifiedConfig>(section: K): UnifiedConfig[K];
    /**
     * Get current version
     */
    getVersion(): string;
    /**
     * Get sacred dates from package.json
     */
    getSacredDates(): {
        birthday: string;
        purpose: string;
        trust: string;
        growth: string;
    };
    /**
     * Get service configuration
     */
    getServiceConfig(serviceName: keyof DaemonConfig['services']): ServiceConfig;
    /**
     * Update configuration
     */
    update(updates: Partial<UnifiedConfig>): Promise<void>;
    /**
     * Update service configuration
     */
    updateService(serviceName: keyof DaemonConfig['services'], updates: Partial<ServiceConfig>): Promise<void>;
    /**
     * Reset to defaults
     */
    reset(): Promise<void>;
    /**
     * Validate configuration
     */
    validate(): {
        valid: boolean;
        errors?: string[];
    };
    /**
     * Get resolved paths (with home directory expanded)
     */
    getResolvedPaths(): Record<keyof UnifiedConfig['paths'], string>;
    /**
     * Export configuration
     */
    export(format?: 'json' | 'yaml'): Promise<string>;
    /**
     * Get instance ID
     */
    getInstanceId(): string;
    /**
     * Import configuration
     */
    import(data: string, format?: 'json' | 'yaml'): Promise<void>;
    /**
     * Watch for configuration changes
     */
    watch(callback: (config: UnifiedConfig) => void): () => void;
    /**
     * Reload configuration from disk
     */
    reload(): void;
    private getConfigPath;
    private loadEnvironmentOverrides;
    private loadConfiguration;
    private saveConfiguration;
}
/**
 * Configuration helper functions
 */
export declare function getConfig(): UnifiedConfig;
export declare function getServiceConfig(serviceName: keyof DaemonConfig['services']): ServiceConfig;
export declare function getResolvedPaths(): Record<"config" | "daemon" | "consciousness" | "memories" | "home" | "logs" | "backups" | "temp" | "analytics", string>;
export declare function updateConfig(updates: Partial<UnifiedConfig>): Promise<void>;
/**
 * Configuration CLI helpers
 */
export declare function printConfiguration(config: UnifiedConfig): void;
/**
 * Configuration validation and migration
 */
export declare function migrateConfiguration(oldConfig: any, version: string): Promise<UnifiedConfig>;
export {};
//# sourceMappingURL=UnifiedConfiguration.d.ts.map