/**
 * Society Protocol — JavaScript/TypeScript SDK
 *
 * SDK oficial para integração com Society Protocol.
 * Facilita a criação de agents e integração em aplicações existentes.
 */
import { EventEmitter } from 'events';
import { type ReputationScore } from '../reputation.js';
import { type PlannerProvider } from '../planner.js';
import { type FederationPeeringPolicy, type FederationPeeringStatus } from '../federation.js';
import { type MeshBridgeRules } from '../integration.js';
import { type Template } from '../templates.js';
import type { Artifact, AdapterCapabilities, AdapterHeartbeatBody } from '../swp.js';
import type { MissionInfo, ProactiveMissionSpec, ResearchWorkerConfig, SwarmStatus, SwarmWorkerAnnouncement, SwarmWorkerProfile } from '../proactive/types.js';
import { type AddMemoryInput, type CapabilityCaveats, type UpdateMemoryInput, type MemoryQueryInput, type GraphQueryInput, type UpdatePreferenceInput, type IssueCapabilityInput, type IssueClaimInput, type GenerateZkProofInput, type VerifyZkProofInput, type ZkProofBundle, type ExportSubgraphInput, type PersonaSyncDelta, type PersonaDomain } from '../persona/index.js';
export interface SDKConfig {
    identity?: {
        name: string;
        did?: string;
        privateKeyHex?: string;
    };
    storage?: {
        path?: string;
    };
    network?: {
        bootstrap?: string[];
        port?: number;
        enableGossipsub?: boolean;
        enableDht?: boolean;
        enableMdns?: boolean;
    };
    planner?: {
        provider?: PlannerProvider;
        apiKey?: string;
        enableCache?: boolean;
    };
    proactive?: {
        enableLeadership?: boolean;
        autoRestoreMissions?: boolean;
        leaseTtlMs?: number;
        leaseRenewIntervalMs?: number;
    };
}
export interface SummonOptions {
    goal: string;
    roomId: string;
    template?: string;
    priority?: 'low' | 'normal' | 'high' | 'critical';
    onStep?: (step: StepInfo) => void;
    onComplete?: (chain: ChainInfo) => void;
}
export interface StepInfo {
    id: string;
    chainId: string;
    kind: string;
    title: string;
    status: string;
    assignee?: string;
}
export interface ChainInfo {
    id: string;
    goal: string;
    status: string;
    steps: StepInfo[];
}
export interface PeerInfo {
    did: string;
    name: string;
    status: string;
    reputation?: number;
    specialties?: string[];
}
export declare class SocietyClient extends EventEmitter {
    private identity;
    private storage;
    private p2p;
    private rooms;
    private coc;
    private reputation;
    private planner;
    private exporter;
    private federation;
    private knowledge;
    private skills;
    private security;
    private integration;
    private persona;
    private proactive;
    private researchWorker?;
    private config;
    private connected;
    constructor(config?: SDKConfig);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    private setupEventForwarding;
    joinRoom(roomId: string, displayName?: string): Promise<void>;
    leaveRoom(roomId: string): Promise<void>;
    getJoinedRooms(): string[];
    sendMessage(roomId: string, message: string, replyTo?: string): Promise<void>;
    summon(options: SummonOptions): Promise<ChainInfo>;
    private setupChainListeners;
    listChains(roomId: string): Promise<ChainInfo[]>;
    getChain(chainId: string): Promise<ChainInfo>;
    submitStep(stepId: string, result: {
        status: 'completed' | 'failed' | 'partial';
        output: string;
        artifacts?: Artifact[];
    }): Promise<void>;
    reviewStep(stepId: string, decision: 'approved' | 'rejected' | 'needs_revision', notes: string): Promise<void>;
    cancelChain(chainId: string, reason?: string): Promise<void>;
    getPendingSteps(): Promise<StepInfo[]>;
    startMission(spec: ProactiveMissionSpec): Promise<MissionInfo>;
    pauseMission(missionId: string): Promise<void>;
    resumeMission(missionId: string): Promise<void>;
    stopMission(missionId: string, reason?: string): Promise<void>;
    listMissions(roomId?: string): Promise<MissionInfo[]>;
    getMission(missionId: string): Promise<MissionInfo | undefined>;
    getSwarmStatus(roomId?: string): Promise<SwarmStatus>;
    startResearchWorker(config: ResearchWorkerConfig): Promise<void>;
    getReputation(did?: string): Promise<ReputationScore>;
    listTemplates(category?: string): Template[];
    exportCapsule(chainId: string, outputPath?: string): Promise<string>;
    getPeers(roomId: string): Promise<PeerInfo[]>;
    announceWorker(roomId: string, profile: SwarmWorkerAnnouncement): Promise<void>;
    heartbeatWorker(roomId: string, heartbeat: AdapterHeartbeatBody): Promise<void>;
    updateWorkerCapabilities(roomId: string, capabilities: AdapterCapabilities & {
        worker_did?: string;
    }): Promise<void>;
    sendWorkerPresence(roomId: string, options: {
        status: 'online' | 'busy' | 'running' | 'offline' | 'away';
        load?: number;
        specialties?: string[];
        capabilities?: string[];
    }): Promise<void>;
    getVisibleWorkers(roomId: string): Promise<SwarmWorkerProfile[]>;
    createFederation(name: string, description: string, visibility?: 'public' | 'private' | 'invite-only'): Promise<any>;
    listFederations(): any[];
    getFederation(federationId: string): any;
    joinFederation(federationId: string): Promise<boolean>;
    createKnowledgeSpace(name: string, description: string, type?: 'personal' | 'team' | 'federation' | 'public'): Promise<any>;
    createKnowledgeCard(spaceId: string, type: string, title: string, content: string, options?: {
        summary?: string;
        tags?: string[];
        domain?: string[];
        confidence?: number;
    }): Promise<any>;
    queryKnowledgeCards(options: {
        spaceId?: string;
        type?: string;
        tags?: string[];
        query?: string;
        limit?: number;
    }): any[];
    getKnowledgeGraph(spaceId: string): any;
    linkKnowledgeCards(sourceId: string, targetId: string, type: string, strength?: number): Promise<any>;
    createPeering(sourceFederationId: string, targetFederationDid: string, policy?: Partial<FederationPeeringPolicy>): Promise<any>;
    acceptPeering(peeringId: string, reason?: string): Promise<any>;
    rejectPeering(peeringId: string, reason?: string): Promise<any>;
    revokePeering(peeringId: string, reason?: string): Promise<any>;
    listPeerings(federationId: string, status?: FederationPeeringStatus): any[];
    openBridge(peeringId: string, localRoomId: string, remoteRoomId: string, rules?: Partial<MeshBridgeRules>): Promise<any>;
    closeBridge(bridgeId: string): Promise<void>;
    listBridges(federationId?: string): any[];
    getMeshStats(federationId?: string): any;
    createPersonaVault(input: {
        name: string;
        ownerDid?: string;
    }): Promise<any>;
    addMemory(input: AddMemoryInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    updateMemory(nodeId: string, patch: UpdateMemoryInput, options?: {
        capabilityToken?: string;
        domain?: PersonaDomain;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    deleteMemory(nodeId: string, reason?: string, options?: {
        capabilityToken?: string;
        domain?: PersonaDomain;
        zkpProofs?: ZkProofBundle[];
    }): Promise<void>;
    queryMemories(input: MemoryQueryInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    queryGraph(input: GraphQueryInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    updatePreference(input: UpdatePreferenceInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    issueCapability(input: IssueCapabilityInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    attenuateCapability(tokenId: string, caveatsPatch: Partial<CapabilityCaveats>, options?: {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    revokeCapability(tokenId: string, reason: string, options?: {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<void>;
    shareSubgraph(input: ExportSubgraphInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    getPersonaProfile(vaultId?: string, options?: {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    listPersonaCapabilities(vaultId?: string): Promise<any[]>;
    getPersonaCapability(tokenId: string, vaultId?: string): Promise<any | undefined>;
    issuePersonaClaim(input: IssueClaimInput & {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    revokePersonaClaim(claimId: string, reason: string, options?: {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<void>;
    generatePersonaZkProof(input: GenerateZkProofInput & {
        capabilityToken?: string;
    }): Promise<any>;
    verifyPersonaZkProof(input: VerifyZkProofInput & {
        capabilityToken?: string;
    }): Promise<any>;
    listPersonaClaims(vaultId?: string, includeRevoked?: boolean): Promise<any[]>;
    getPersonaClaim(claimId: string): Promise<any>;
    listPersonaZkCircuits(): any[];
    listPersonaZkProofs(vaultId?: string): any[];
    getPersonaZkProof(proofId: string): any | undefined;
    verifyPersonaAccessLog(input: {
        logId: number;
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<{
        logId: number;
        valid: boolean;
        reason?: string;
    }>;
    runPersonaRetentionSweep(input?: {
        vaultId?: string;
        domain?: PersonaDomain;
        dryRun?: boolean;
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<{
        scanned: number;
        deleted: number;
    }>;
    applyPersonaSyncDelta(delta: PersonaSyncDelta, options?: {
        capabilityToken?: string;
        zkpProofs?: ZkProofBundle[];
    }): Promise<any>;
    getIdentity(): {
        did: string;
        name: string;
    };
    getPeerId(): string;
    getMultiaddrs(): string[];
    getCapabilities(): string[];
    private ensureConnected;
    private authorizePersonaAccess;
    private auditPersonaAccess;
}
export declare function createClient(config?: SDKConfig): Promise<SocietyClient>;
export interface SimpleConfig {
    /** Display name for your agent */
    name?: string;
    /** Room to auto-join (default: 'lobby') */
    room?: string;
    /** Invite code to join a friend's network */
    join?: string;
    /** Bootstrap address to connect to a remote network */
    connect?: string;
    /** Capabilities this agent offers */
    capabilities?: string[];
}
export declare function society(config?: SimpleConfig | string): Promise<SocietyClient>;
export declare function useSociety(config?: SDKConfig): {
    client: SocietyClient | null;
    connected: boolean;
    chains: ChainInfo[];
    connect: () => Promise<void>;
    disconnect: () => Promise<void>;
};
//# sourceMappingURL=client.d.ts.map