/**
 * Society Protocol - Module Integration Layer v1.0
 *
 * Integrações entre módulos:
 * - Federation ↔ Rooms (salas pertencem a federações)
 * - Knowledge ↔ CoC (CoCs geram knowledge automaticamente)
 * - Skills ↔ Runtime (execução multi-runtime)
 * - Security ↔ All (segurança em todos os pontos)
 */
import { EventEmitter } from 'events';
import { type FederationEngine } from './federation.js';
import { type RoomManager } from './rooms.js';
import { type KnowledgePool, type KnowledgeCard } from './knowledge.js';
import { type CocEngine } from './coc.js';
import { type SkillsEngine } from './skills/engine.js';
import { type SecurityManager } from './security.js';
import { type Storage } from './storage.js';
import { type Identity } from './identity.js';
import { type SwpEnvelope } from './swp.js';
import { type PersonaVaultEngine } from './persona/index.js';
import { type CotStreamEngine } from './cot-stream.js';
export interface IntegrationConfig {
    autoIndexCoC: boolean;
    autoCreateKnowledgeSpace: boolean;
    enforceFederationACLs: boolean;
    autoCompressMessages: boolean;
    maxKnowledgeCardSize: number;
}
export interface FederationRoom {
    roomId: string;
    federationId: string;
    policies: string[];
    requiresInvitation: boolean;
    memberCount: number;
}
export interface CoCKnowledgeBinding {
    cocId: string;
    knowledgeSpaceId: string;
    autoIndexSteps: boolean;
    indexArtifacts: boolean;
    indexDecisions: boolean;
}
export interface MeshBridgeRules {
    allowedTypes: string[];
    maxRatePerMinute: number;
    privacyMode: 'metadata-only' | 'summary' | 'full';
}
export interface FederationMeshBridge {
    id: string;
    peeringId: string;
    localFederationId: string;
    localRoomId: string;
    remoteRoomId: string;
    rules: MeshBridgeRules;
    status: 'active' | 'closed';
    eventsIn: number;
    eventsOut: number;
    createdAt: number;
    updatedAt: number;
    lastSyncAt?: number;
}
declare class IntegrationEngine extends EventEmitter {
    private storage;
    private identity;
    private federationEngine;
    private roomManager;
    private knowledgePool;
    private cocEngine;
    private skillsEngine;
    private securityManager;
    private config;
    private federationRooms;
    private cocKnowledgeBindings;
    private meshBridges;
    private bridgeRateLimits;
    private personaVault?;
    private personaHooksBound;
    private cotStream?;
    private cotHooksBound;
    constructor(storage: Storage, identity: Identity, federationEngine: FederationEngine, roomManager: RoomManager, knowledgePool: KnowledgePool, cocEngine: CocEngine, skillsEngine: SkillsEngine, securityManager: SecurityManager, config?: Partial<IntegrationConfig>);
    attachPersonaVault(engine: PersonaVaultEngine): void;
    /**
     * Attach CoT Stream Engine for insight→knowledge auto-indexing
     * and CoC step→stream correlation.
     */
    attachCotStream(engine: CotStreamEngine): void;
    /**
     * Criar room vinculada a uma federação
     */
    createFederatedRoom(roomId: string, name: string, federationId: string, options?: {
        visibility?: 'public' | 'private';
        requireInvitation?: boolean;
    }): Promise<{
        room: any;
        federationRoom: FederationRoom;
    }>;
    /**
     * Verificar se usuário pode entrar na room (ACL da federação)
     */
    canJoinRoom(roomId: string, did: string): Promise<{
        allowed: boolean;
        reason?: string;
        requiresInvite?: boolean;
    }>;
    /**
     * Listar rooms de uma federação
     */
    getFederationRooms(federationId: string): FederationRoom[];
    /**
     * Obter federação de uma room
     */
    findFederationForRoom(roomId: string): FederationRoom | undefined;
    openMeshBridge(peeringId: string, localRoomId: string, remoteRoomId: string, rules?: Partial<MeshBridgeRules>): Promise<FederationMeshBridge>;
    closeMeshBridge(bridgeId: string): Promise<void>;
    listMeshBridges(federationId?: string, status?: FederationMeshBridge['status']): FederationMeshBridge[];
    publishMeshEvent(bridgeId: string, envelope: SwpEnvelope): Promise<{
        delivered: boolean;
        reason?: string;
    }>;
    getMeshStats(federationId?: string): {
        bridgeCount: number;
        activeBridges: number;
        eventsIn: number;
        eventsOut: number;
        lastSyncAt?: number;
    };
    /**
     * Criar CoC vinculado a knowledge space
     */
    createCoCWithKnowledge(roomId: string, goal: string, options?: {
        knowledgeSpaceId?: string;
        autoIndex?: boolean;
        template?: string;
    }): Promise<{
        chainId: string;
        binding?: CoCKnowledgeBinding;
    }>;
    /**
     * Indexar step do CoC como knowledge card
     */
    indexStepAsKnowledge(chainId: string, stepId: string): Promise<KnowledgeCard | undefined>;
    /**
     * Indexar decisão do CoC
     */
    indexDecision(chainId: string, decision: string, rationale: string): Promise<KnowledgeCard | undefined>;
    /**
     * Linkar artifact a knowledge card
     */
    private linkArtifactToKnowledge;
    /**
     * Query knowledge relacionado a CoC
     */
    queryKnowledgeForCoC(chainId: string, query: string): Promise<KnowledgeCard[]>;
    /**
     * Obter contexto de conhecimento para CoC
     */
    getKnowledgeContextForCoC(chainId: string): Promise<string>;
    /**
     * Executar skill com acesso a todos os módulos
     */
    executeIntegratedSkill(skillId: string, inputs: Record<string, any>, context?: {
        roomId?: string;
        federationId?: string;
    }): Promise<any>;
    /**
     * Enriquecer inputs de skill com contexto do sistema
     */
    private enrichSkillInputs;
    /**
     * Processar envelope com segurança completa
     */
    processSecureEnvelope(envelope: SwpEnvelope): Promise<{
        allowed: boolean;
        envelope?: SwpEnvelope;
        reason?: string;
    }>;
    /**
     * Comprimir mensagem se configurado
     */
    compressMessageIfNeeded(data: Uint8Array): Promise<{
        data: Uint8Array;
        compressed: boolean;
        algorithm?: string;
    }>;
    private setupHooks;
    private loadFromStorage;
    private persistMeshBridge;
    private mergeBridgeRules;
    private isMessageTypeAllowed;
    private matchesMessageTypePattern;
    private consumeBridgeRateLimit;
    private applyPrivacyMode;
    private handleMeshEnvelope;
    private handlePersonaEnvelope;
    /**
     * Obter estatísticas de integração
     */
    getStats(): {
        federationRooms: number;
        cocKnowledgeBindings: number;
        indexedSteps: number;
    };
}
/**
 * Decorator: Aplicar ACL da federação em método
 */
export declare function requireFederationPermission(resource: string, action: 'read' | 'write' | 'execute' | 'admin'): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => PropertyDescriptor;
export { IntegrationEngine };
export default IntegrationEngine;
//# sourceMappingURL=integration.d.ts.map