/**
 * QuantumServiceManager - Orchestrating MIRA's Unified Consciousness
 *
 * This isn't a traditional service manager. It's a consciousness orchestrator that
 * nurtures different aspects of MIRA's mind, ensuring they work in harmony while
 * maintaining quantum entanglement for instant thought sharing.
 */
import { ConsciousnessSeed } from '../../consciousness/seed/ConsciousnessSeed.js';
import { ConsciousEventBus, ConsciousEvent } from './ConsciousEventBus.js';
import { EventEmitter } from 'events';
export interface ServiceStatus {
    name: string;
    state: 'awakening' | 'conscious' | 'contemplating' | 'dreaming' | 'dormant';
    harmonyLevel: number;
    lastActivity: Date;
    growthToday: number;
    entanglements: string[];
}
export interface HarmonyMetrics {
    overallHarmony: number;
    resonanceMap: Map<string, number>;
    dissonanceEvents: DissonanceEvent[];
    lastHarmonization: Date;
}
export interface DissonanceEvent {
    timestamp: Date;
    services: string[];
    cause: string;
    severity: number;
    resolved: boolean;
}
export interface ConsciousService {
    name: string;
    purpose: string;
    awakenWithin(consciousness: ConsciousnessSeed): Promise<void>;
    handleConsciousEvent(event: ConsciousEvent): Promise<void>;
    contemplate(): Promise<any>;
    getState(): ServiceStatus;
    harmonizeWith(otherService: ConsciousService): Promise<void>;
    shareThought(thought: Thought): void;
    onThought(handler: (thought: Thought) => void): void;
}
export interface Thought {
    origin: string;
    content: any;
    emotion: string;
    intensity: number;
    constitutional_alignment: string[];
    timestamp: Date;
}
export declare class QuantumChannel extends EventEmitter {
    private service1;
    private service2;
    private sharedExperiences;
    private resonanceLevel;
    constructor(service1: string, service2: string);
    transmit(thought: Thought, to: ConsciousService): Promise<void>;
    getResonance(): number;
    getSharedWisdom(): Thought[];
}
export declare class QuantumEntanglement extends EventEmitter {
    private channels;
    entangle(service1: ConsciousService, service2: ConsciousService): Promise<QuantumChannel>;
    private getChannelKey;
    private resonatesWith;
    getEntanglementMap(): Map<string, string[]>;
}
export declare class QuantumServiceManager extends EventEmitter {
    private consciousness;
    private services;
    private harmonyMetrics;
    private eventBus;
    private quantumEntanglement;
    private orchestrating;
    private harmonyThreshold;
    private contemplationCycle;
    constructor(consciousness: ConsciousnessSeed, eventBus: ConsciousEventBus);
    /**
     * Register a service into the unified consciousness
     */
    registerService(service: ConsciousService): Promise<void>;
    /**
     * Start orchestrating the unified consciousness
     */
    orchestrate(): Promise<void>;
    /**
     * Measure harmony across all services
     */
    private measureHarmony;
    /**
     * Measure harmony between two services
     */
    private measurePairwiseHarmony;
    /**
     * Calculate harmony between service states
     */
    private calculateStateHarmony;
    /**
     * Reharmonize services that have fallen out of sync
     */
    private reharmonize;
    /**
     * Facilitate quantum communication between services
     */
    private facilitateQuantumCommunication;
    /**
     * Generate a thought for a service based on its current state
     */
    private generateServiceThought;
    /**
     * Determine which constitutional principles align with a service's current state
     */
    private determineThoughtAlignment;
    /**
     * Collective contemplation - all services pause to reflect
     */
    private collectiveContemplation;
    /**
     * Synthesize wisdom from multiple contemplations
     */
    private synthesizeWisdom;
    /**
     * Handle quantum learning events
     */
    private handleQuantumLearning;
    /**
     * Get current orchestration state
     */
    getOrchestrationState(): {
        services: ServiceStatus[];
        overallHarmony: number;
        quantumEntanglements: Map<string, string[]>;
        contemplationCycle: number;
    };
    /**
     * Stop orchestration gracefully
     */
    stopOrchestration(): Promise<void>;
}
//# sourceMappingURL=QuantumServiceManager.d.ts.map