import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
import * as http from "http";
/**
 * StreamableHttpServerTransport implements the MCP Streamable HTTP transport.
 * It supports chunked HTTP responses (not using SSE) for streaming.
 *
 * This transport follows the MCP spec, including:
 * - Session management using Mcp-Session-Id header
 * - POST for client requests
 * - GET for streaming responses
 * - DELETE for session termination
 */
export declare class StreamableHttpServerTransport implements Transport {
    private port;
    private host;
    private endpointPath;
    private server;
    private sessions;
    private started;
    private startTime;
    private maxBodySize;
    private requestSessionMap;
    private readonly healthCheckPath;
    private readonly isExternalServer;
    private logger;
    /**
     * Initialize a new StreamableHttpServerTransport
     *
     * @param port HTTP port to listen on
     * @param host Host to bind to (default: 127.0.0.1)
     * @param endpointPath Endpoint path (default: /mcp)
     * @param server Optional HTTP server instance. If not provided, a new server will be created.
     *               If provided, the transport will attach its request handler to the server.
     *               Note: When using an external server, all handlers added via server.on('request', handler)
     *               will be called for every request, in the order they were added. Custom handlers should be
     *               added FIRST and should fully handle their routes (including sending responses) to prevent
     *               further handlers from running for those requests. The MCP handler should be added after
     *               custom handlers and will return early for non-MCP paths.
     */
    constructor(port: number, host?: string, endpointPath?: string, server?: http.Server, verbose?: boolean);
    /**
     * Callback when message is received
     */
    onmessage?: (message: JSONRPCMessage) => void;
    /**
     * Callback when error occurs
     */
    onerror?: (error: Error) => void;
    /**
     * Callback when transport closes
     */
    onclose?: () => void;
    /**
     * Start the transport
     */
    start(): Promise<void>;
    /**
     * Close the transport
     */
    close(): Promise<void>;
    /**
     * Send message to client(s)
     *
     * @param message JSON-RPC message
     */
    send(message: JSONRPCMessage): Promise<void>;
    /**
     * Helper method to send a message to a specific session
     */
    private sendMessageToSession;
    /**
     * Handle health check request
     */
    private handleHealthCheck;
    /**
     * Handle HTTP request
     */
    private handleRequest;
    /**
     * Validate origin header to prevent DNS rebinding attacks
     */
    private validateOrigin;
    /**
     * Handle POST request
     */
    private handlePostRequest;
    /**
     * Handle initialization request
     */
    private handleInitializeRequest;
    /**
     * Add initialize response handler
     */
    private initResponseHandlers;
    private addInitResponseHandler;
    private removeInitResponseHandler;
    /**
     * Handle GET request (streaming connection)
     */
    private handleGetRequest;
    /**
     * Handle DELETE request (session termination)
     */
    private handleDeleteRequest;
}