import { type ServeOptions, type Server, type WebSocketUpgradeResponse } from "../../base.js";
import type { NodeHttpServer, WSWebSocket, WSWebSocketServer } from "./types.js";
import { type NodeWebSocketServerOptions } from "../../../../extensions/websocket/index.js";
/** Private correlation header injected by Node upgrade transports. */
export declare const NODE_WEBSOCKET_UPGRADE_ID_HEADER = "x-veryfront-node-upgrade-id";
export declare class NodeServer implements Server {
    private server;
    private hostname;
    private port;
    private disposeUpgrades;
    private detachTransportListeners;
    private stopPromise;
    private upgradesDisposed;
    private httpStopped;
    private transportListenersDetached;
    private transportState;
    private transportCloseObserver;
    constructor(server: NodeHttpServer, hostname: string, port: number, disposeUpgrades?: () => void | Promise<void>, detachTransportListeners?: () => void);
    stop(): Promise<void>;
    private stopInternal;
    get addr(): {
        hostname: string;
        port: number;
    };
    /** @internal Native transport for compatibility facades that expose Node's server. */
    get nativeHttpServer(): import("node:http").Server;
    /** @internal Update an ephemeral (`port: 0`) listener with its bound port. */
    setListeningPort(port: number): void;
    /** @internal Mark the native listen request as pending. */
    markListenStarted(): void;
}
export declare function registerWebSocketUpgrade(requestId: string): Promise<WSWebSocket>;
export declare function hasPendingWebSocketUpgrade(requestId: string): boolean;
export declare function resolveWebSocketUpgrade(requestId: string, ws: WSWebSocket): boolean;
/** Reject and remove a pending transport upgrade, if one exists. */
export declare function rejectWebSocketUpgrade(requestId: string, error: Error): boolean;
/**
 * Request-scoped handshake metadata shared with `ws`.
 *
 * `ws` otherwise auto-selects the first offered subprotocol and owns the wire
 * response headers. Both Node server entry points use this controller so the
 * application-selected protocol and custom headers are applied exactly once.
 */
export declare class NodeWebSocketHandshakeController {
    private readonly metadata;
    readonly serverOptions: NodeWebSocketServerOptions;
    attach(server: Pick<WSWebSocketServer, "on">): void;
    authorize(request: object, response: WebSocketUpgradeResponse): void;
    release(request: object): void;
}
export type NodeRequestHandler = (request: Request) => Promise<Response | WebSocketUpgradeResponse> | Response | WebSocketUpgradeResponse;
/**
 * Create the canonical Node listener for Web Request/Response handlers.
 *
 * This owns disconnect propagation, response backpressure, streaming failure
 * containment, and listener cleanup for both Platform and public compatibility
 * surfaces.
 */
export declare function createNodeRequestListener(handler: NodeRequestHandler, fallbackHostname?: string): (request: import("node:http").IncomingMessage, response: import("node:http").ServerResponse) => Promise<void>;
export declare function createNodeServer(handler: NodeRequestHandler, options?: ServeOptions): Promise<Server>;
/** @internal Publish startup cleanup ownership before listener readiness. */
export declare function createNodeServerWithStartupOwner(handler: NodeRequestHandler, options: ServeOptions, ownStartupServer: (server: NodeServer) => void): Promise<NodeServer>;
//# sourceMappingURL=http-server.d.ts.map