import { type IncomingMessage, type ServerResponse } from "node:http";
import type { Server } from "../../tiny-stdio-mcp-server/dist/index.js";
import { type SessionStore } from "./session.js";
export type HttpObservabilityEvent = {
    type: "request.start";
    requestId: string;
    method: string;
    path: string;
    sessionId?: string;
} | {
    type: "request.end";
    requestId: string;
    method: string;
    statusCode: number;
    durationMs: number;
    sessionId?: string;
    reason?: string;
} | {
    type: "request.error";
    requestId: string;
    method: string;
    durationMs: number;
    error: unknown;
    sessionId?: string;
} | {
    type: "auth.failure";
    statusCode: number;
    challenge?: string;
    sessionId?: string;
} | {
    type: "session.created";
    sessionId: string;
} | {
    type: "session.deleted";
    sessionId: string;
    reason: "client" | "expired" | "closed";
} | {
    type: "stream.opened";
    sessionId: string;
    streamCount: number;
} | {
    type: "stream.closed";
    sessionId: string;
    streamCount: number;
} | {
    type: "tool.start";
    requestId: string;
    sessionId?: string;
    toolName?: string;
} | {
    type: "tool.end";
    requestId: string;
    sessionId?: string;
    toolName?: string;
    ok: boolean;
    durationMs: number;
};
export interface HttpObservabilityOptions {
    onEvent?(event: HttpObservabilityEvent): void;
}
export interface StreamableHttpTransportOptions {
    sessionIdGenerator?: (() => string) | undefined;
    enableJsonResponse?: boolean;
    allowedOrigins?: readonly string[];
    allowedHosts?: readonly string[];
    maxRequestBytes?: number;
    maxBatchSize?: number;
    maxSessions?: number;
    sessionTtlMs?: number;
    maxStreamsPerSession?: number;
    maxStreamBufferBytes?: number;
    maxSseEventHistory?: number;
    sseKeepAliveMs?: number;
    maxConcurrentToolCalls?: number;
    sessionStore?: SessionStore;
    requestIdGenerator?: () => string;
    observability?: HttpObservabilityOptions;
    trustedProxy?: boolean;
}
type RequestContextRunner = <T>(req: IncomingMessage, callback: () => Promise<T>) => Promise<T>;
export declare class StreamableHttpTransport {
    private readonly server;
    private readonly runWithRequestContext;
    private readonly sessionIdGenerator;
    private readonly enableJsonResponse;
    private readonly allowedOrigins;
    private readonly allowedHosts;
    private readonly maxRequestBytes;
    private readonly maxBatchSize;
    private readonly maxSessions;
    private readonly sessionTtlMs;
    private readonly maxStreamsPerSession;
    private readonly maxStreamBufferBytes;
    private readonly maxSseEventHistory;
    private readonly sseKeepAliveMs;
    private readonly maxConcurrentToolCalls;
    private readonly sessionStore;
    private readonly requestIdGenerator;
    private readonly observability;
    private readonly trustedProxy;
    private readonly sessionMessages;
    private readonly sseStreams;
    private readonly sseExpiryTimers;
    private readonly sseEventHistory;
    private readonly responseRequestIds;
    private readonly responseOrigins;
    private readonly responseRejectionReasons;
    private nextNotificationEventId;
    private nextRequestId;
    private activeToolCalls;
    private closed;
    private sessionExpiryInterval;
    private sseKeepAliveInterval;
    constructor(server: Server, options?: StreamableHttpTransportOptions, runWithRequestContext?: RequestContextRunner);
    handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void>;
    close(): Promise<void>;
    private handlePost;
    private handleGet;
    private handleDelete;
    private handleOptions;
    private readSessionId;
    private acceptsProtocolVersion;
    private readRequestId;
    private readOrigin;
    private readToolName;
    private getActiveSession;
    private readAuthSubject;
    private touchSession;
    private isExpired;
    private purgeExpiredSessions;
    private sessionCount;
    private deleteSession;
    private createLocalMessageSession;
    private ensureLocalMessageSession;
    private closeStreamsForSession;
    private scheduleSseExpiry;
    private clearSseExpiryTimer;
    private startSseKeepAlive;
    private stopSseKeepAliveIfIdle;
    private stopSseKeepAlive;
    private sendNotificationToSession;
    private writeToLiveGetStream;
    private recordSseEvent;
    private replaySseEvents;
    private isJsonRequest;
    private acceptsOrigin;
    private acceptsOriginValue;
    private readRequestProtocol;
    private readRequestHost;
    private readForwardedHeader;
    private acceptsHost;
    private normalizeHost;
    private acceptsConfiguredResponse;
    private acceptsResponseType;
    private isValidNewSessionId;
    private isRequest;
    private isToolCallOk;
    private respondWithJsonRpcError;
    private respondWithRejection;
    private respondWithStatus;
    private withSessionHeader;
    private emit;
}
export {};