import { EventStreamHandle, TransportAdapter } from "../transport.js";
import { ProtocolSseTransportOptions } from "./types.js";
import { Command, CommandResponse, ErrorResponse, Message, SubscribeParams } from "@langchain/protocol";

//#region src/client/stream/transport/http.d.ts
/**
 * Transport adapter that speaks the thread-centric protocol over HTTP
 * commands plus SSE event streams. Bound to a `threadId` at construction
 * or later via {@link setThreadId}; request URLs derive from the
 * currently-bound thread. Each {@link openEventStream} call opens an
 * independent filtered SSE connection via
 * `POST /threads/:thread_id/stream/events`.
 */
declare class ProtocolSseTransportAdapter implements TransportAdapter {
  threadId: string;
  readonly apiUrl: string;
  private readonly queue;
  private readonly fetchImpl;
  private readonly defaultHeaders;
  private readonly onRequest?;
  private readonly fetchFactory?;
  private readonly asyncCaller?;
  private readonly maxReconnectAttempts;
  private readonly idleReconnect;
  private readonly onReconnect?;
  private readonly onConnected?;
  private readonly reconnectDelayMs;
  private readonly paths?;
  private readonly sessionAbortController;
  private readonly eventStreams;
  private closed;
  constructor(options: ProtocolSseTransportOptions);
  /** {@inheritDoc TransportAdapter.setThreadId} */
  setThreadId(threadId: string): void;
  /**
   * Command/stream/state URLs derive from the currently-bound thread so a
   * single adapter can follow {@link setThreadId} re-binds. A fixed
   * `paths.*` string overrides the default and is used as-is.
   */
  private get commandsUrl();
  private get streamUrl();
  private get stateUrl();
  /**
   * Fetch checkpointed thread state for hydration.
   *
   * Uses `GET`, matching `client.threads.getState()` and both LangGraph
   * Platform and Agent Protocol custom backends (`POST` is reserved for
   * `updateState`).
   */
  getState<StateType = unknown>(): Promise<{
    values: StateType;
    next?: unknown;
    tasks?: unknown;
    metadata?: unknown;
    checkpoint?: {
      checkpoint_id?: string;
    } | null;
    parent_checkpoint?: {
      checkpoint_id?: string;
    } | null;
  } | null>;
  private resolveFetch;
  /**
   * HTTP/SSE transports have no handshake — connections are made
   * per-command and per-subscription.
   */
  open(): Promise<void>;
  send(command: Command): Promise<CommandResponse | ErrorResponse | void>;
  /**
   * WebSocket-style single event stream.
   * For the SSE transport this returns a dummy iterable; real event
   * delivery happens via {@link openEventStream}.
   */
  events(): AsyncIterable<Message>;
  openEventStream(params: SubscribeParams): EventStreamHandle;
  close(): Promise<void>;
  private request;
}
//#endregion
export { ProtocolSseTransportAdapter };
//# sourceMappingURL=http.d.ts.map