import { EventEmitter } from 'events';
import { n as TunnelRelayConfig, o as TunnelRelayEvents, A as AgentInfo, R as RelayRpcOptions, H as HeartbeatConfig, a as AuthResult, q as TunnelServerConfig } from '../types-Dpwrd8Ai.js';
import { Hono } from 'hono';

declare class TunnelRelay extends EventEmitter {
    private agents;
    private pendingRPCs;
    private config;
    onAuthorizeRPC?: (tunnelId: string, method: string, params: Record<string, unknown>) => Promise<boolean>;
    constructor(config?: TunnelRelayConfig);
    emitEvent<K extends keyof TunnelRelayEvents>(event: K, data: TunnelRelayEvents[K]): boolean;
    registerAgent(tunnelId: string, ws: WebSocket, signingKey: string, metadata?: Record<string, unknown>): void;
    unregisterAgent(tunnelId: string): void;
    isConnected(tunnelId: string): boolean;
    getConnectedCount(): number;
    getConnectedAgents(): Map<string, AgentInfo>;
    getAgentMetadata(tunnelId: string): Record<string, unknown> | undefined;
    handleAgentMessage(tunnelId: string, raw: string | Buffer): void;
    relayRPC(tunnelId: string, method: string, params: Record<string, unknown>, options?: RelayRpcOptions): Promise<unknown>;
    sendNotification(tunnelId: string, method: string, params?: Record<string, unknown>): boolean;
    shutdown(): void;
}
declare class TunnelRelayError extends Error {
    readonly code: number;
    readonly data?: unknown | undefined;
    constructor(code: number, message: string, data?: unknown | undefined);
}

declare class HeartbeatManager {
    private states;
    private intervalHandle;
    private relay;
    private intervalMs;
    private maxMissed;
    constructor(relay: TunnelRelay, config?: HeartbeatConfig);
    start(): void;
    stop(): void;
    register(tunnelId: string): void;
    unregister(tunnelId: string): void;
    recordPong(tunnelId: string): void;
    private tick;
}

interface WsHandlerOptions {
    heartbeat?: HeartbeatManager;
    maxMessageSize?: number;
    onAuthenticate?: (tunnelId: string, token: string) => Promise<AuthResult | null>;
    authTimeoutMs?: number;
}
interface WsHandlers {
    onOpen(tunnelId: string, ws: WebSocket): void;
    onMessage(tunnelId: string, message: string | Buffer): void;
    onClose(tunnelId: string): void;
}
declare function createWsHandlers(relay: TunnelRelay, opts?: WsHandlerOptions): WsHandlers;

declare function createTunnelRouter(relay: TunnelRelay, onAuthorizeHTTP?: (req: Request) => Promise<boolean>): Hono;

/**
 * Standalone tunnel server — one function call to get a working relay.
 *
 * Usage:
 *   import { startTunnelServer } from 'agent-tunnel';
 *   const server = startTunnelServer({ port: 8080, onAuthenticate: ... });
 *
 * Agents connect via: ws://localhost:8080/ws?tunnelId=yyy
 * Then send { type: "auth", token: "tnl_xxx" } as the first message.
 * Your app calls relay.relayRPC(tunnelId, method, params) to reach the agent.
 */

interface TunnelServer {
    app: Hono;
    relay: TunnelRelay;
    heartbeat: HeartbeatManager;
    wsHandlers: ReturnType<typeof createWsHandlers>;
    stop: () => void;
}
/**
 * Start a tunnel relay server. Handles everything:
 * - HTTP routes for connections list + RPC
 * - WebSocket upgrades on /ws for agent connections
 * - Heartbeat ping/pong
 * - HMAC signing key derivation via onAuthenticate hook
 *
 * Requires Bun runtime for WebSocket server support.
 */
declare function startTunnelServer(config?: TunnelServerConfig): TunnelServer;

export { HeartbeatManager, TunnelRelay, TunnelRelayError, type TunnelServer, type WsHandlerOptions, type WsHandlers, createTunnelRouter, createWsHandlers, startTunnelServer };