/**
 * Distributed Swarm Transport — HTTP/JSON-RPC transport layer
 *
 * Enables multi-node swarm orchestration over the network.
 * Provides:
 *   - SwarmTransportServer — HTTP server that exposes SwarmOrchestrator methods
 *   - SwarmTransportClient — HTTP client that proxies calls to a remote server
 *   - Message envelope with auth, correlation IDs, and TTL
 *
 * Uses Node built-in `http` module — no external dependencies.
 * Communication format: JSON-RPC 2.0 over HTTP POST.
 *
 * Usage (server):
 *   const server = new SwarmTransportServer(orchestrator, { port: 4000 });
 *   await server.start();
 *
 * Usage (client):
 *   const client = new SwarmTransportClient('http://node-2:4000');
 *   const result = await client.delegateTask(agentId, payload);
 *
 * @module SwarmTransport
 * @version 1.0.0
 */
import { EventEmitter } from 'events';
/** Transport message envelope */
export interface TransportEnvelope {
    /** JSON-RPC version */
    jsonrpc: '2.0';
    /** Unique request ID */
    id: string;
    /** Remote method name */
    method: string;
    /** Method parameters */
    params: Record<string, unknown>;
    /** Metadata */
    meta?: TransportMeta;
}
/** Metadata attached to transport messages */
export interface TransportMeta {
    /** Correlation ID for request tracing */
    correlationId: string;
    /** Source node identifier */
    sourceNode: string;
    /** Timestamp of message creation */
    timestamp: number;
    /** Time-to-live in ms (0 = no expiry) */
    ttlMs: number;
    /** HMAC signature if auth is configured */
    signature?: string;
}
/** Transport response */
export interface TransportResponse {
    jsonrpc: '2.0';
    id: string;
    result?: unknown;
    error?: {
        code: number;
        message: string;
        data?: unknown;
    };
}
/** Server configuration */
export interface TransportServerConfig {
    /** Port to listen on (default: 4000) */
    port?: number;
    /** Hostname to bind (default: '127.0.0.1') */
    hostname?: string;
    /** Shared secret for HMAC authentication (optional) */
    sharedSecret?: string;
    /** Maximum request body size in bytes (default: 1MB) */
    maxBodyBytes?: number;
    /** Allowed source nodes (empty = allow all) */
    allowedNodes?: string[];
    /** Node identifier for this server */
    nodeId?: string;
}
/** Client configuration */
export interface TransportClientConfig {
    /** Remote server URL (e.g. 'http://node-2:4000') */
    url: string;
    /** Shared secret for HMAC authentication (must match server) */
    sharedSecret?: string;
    /** This node's identifier */
    nodeId?: string;
    /** Default request timeout in ms (default: 30000) */
    timeoutMs?: number;
    /** Default TTL for messages in ms (default: 60000) */
    ttlMs?: number;
}
/**
 * Handler function for swarm transport methods.
 * Receives parsed params and returns a result.
 */
export type TransportHandler = (params: Record<string, unknown>) => Promise<unknown>;
/**
 * HTTP transport server for distributed swarm orchestration.
 *
 * Exposes registered methods over HTTP POST with JSON-RPC 2.0 protocol.
 * Supports HMAC authentication, node allowlisting, TTL enforcement,
 * and request size limits.
 */
export declare class SwarmTransportServer extends EventEmitter {
    private server;
    private handlers;
    private readonly config;
    constructor(config?: TransportServerConfig);
    /** Register a method handler */
    register(method: string, handler: TransportHandler): void;
    /** Register multiple handlers at once */
    registerAll(handlers: Record<string, TransportHandler>): void;
    /** Start the transport server */
    start(): Promise<void>;
    /** Stop the transport server */
    stop(): Promise<void>;
    /** Get the node ID */
    get nodeId(): string;
    /** Whether the server is running */
    get isRunning(): boolean;
    private handleRequest;
    private readBody;
    private sendResponse;
    private computeHmac;
}
/**
 * HTTP transport client for distributed swarm orchestration.
 *
 * Proxies method calls to a remote SwarmTransportServer over HTTP POST.
 * Supports HMAC authentication, correlation IDs, and TTL.
 */
export declare class SwarmTransportClient extends EventEmitter {
    private readonly config;
    constructor(config: TransportClientConfig);
    /**
     * Call a remote method.
     * @returns The result from the remote handler.
     * @throws If the remote returns an error or the request times out.
     */
    call(method: string, params?: Record<string, unknown>): Promise<unknown>;
    /** Get the node ID */
    get nodeId(): string;
    /** Convenience: delegate a task to a remote orchestrator */
    delegateTask(agentId: string, payload: Record<string, unknown>): Promise<unknown>;
    /** Convenience: read from remote blackboard */
    blackboardRead(key: string): Promise<unknown>;
    /** Convenience: write to remote blackboard */
    blackboardWrite(key: string, value: unknown, proposer?: string): Promise<unknown>;
    /** Convenience: query remote budget status */
    budgetStatus(): Promise<unknown>;
}
//# sourceMappingURL=swarm-transport.d.ts.map