import { Writable, Readable } from 'readable-stream';
import { EventEmitter } from 'eventemitter3';
import { Socket } from './net';
export declare const STATUS_CODES: Record<number, string>;
export declare const METHODS: string[];
export declare class IncomingMessage extends Readable {
    httpVersion: string;
    httpVersionMajor: number;
    httpVersionMinor: number;
    method?: string;
    url?: string;
    statusCode?: number;
    statusMessage?: string;
    headers: Record<string, string | string[]>;
    rawHeaders: string[];
    socket: Socket;
    aborted: boolean;
    complete: boolean;
    trailers: Record<string, string>;
    constructor(socket: Socket);
    _read(): void;
    setTimeout(msecs: number, callback?: () => void): this;
    destroy(error?: Error): this;
    setNoDelay(noDelay?: boolean): void;
    setKeepAlive(enable?: boolean, initialDelay?: number): void;
}
export declare class OutgoingMessage extends Writable {
    headersSent: boolean;
    protected _headers: Record<string, any>;
    protected _headerNames: Record<string, string>;
    socket: Socket | null;
    chunkedEncoding: boolean;
    protected _hasBody: boolean;
    protected _sendHeadersSent: boolean;
    aborted: boolean;
    protected _trailers: Record<string, string> | null;
    constructor();
    destroy(error?: Error): this;
    setHeader(name: string, value: any): this;
    getHeader(name: string): any;
    removeHeader(name: string): void;
    hasHeader(name: string): boolean;
    getHeaderNames(): string[];
    setTimeout(ms: number, callback?: () => void): this;
    protected _renderHeaders(firstLine: string): string;
    protected _sendHeaders(firstLine: string): void;
    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
    write(chunk: any, encoding?: any, callback?: any): boolean;
    _final(callback: (error?: Error | null) => void): void;
    addTrailers(headers: Record<string, string>): void;
    end(chunk?: any, encoding?: any, callback?: any): this;
    setNoDelay(noDelay?: boolean): void;
    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
}
export declare class ServerResponse extends OutgoingMessage {
    statusCode: number;
    statusMessage?: string;
    socket: Socket;
    constructor(socket: Socket);
    writeHead(statusCode: number, statusMessage?: string | Record<string, any>, headers?: Record<string, any>): this;
    private _sendResponseHeaders;
    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
    write(chunk: any, encoding?: any, callback?: any): boolean;
    end(chunk?: any, encoding?: any, callback?: any): this;
}
export interface ServerOptions {
    /**
     * Optionally overrides all net.Server options.
     */
    IncomingMessage?: typeof IncomingMessage;
    ServerResponse?: typeof ServerResponse;
    /**
     * Keep-Alive header timeout in milliseconds.
     */
    keepAliveTimeout?: number;
    /**
     * Request timeout in milliseconds.
     */
    requestTimeout?: number;
    /**
     * Headers timeout in milliseconds.
     */
    headersTimeout?: number;
    /**
     * Max header size in bytes.
     */
    maxHeaderSize?: number;
    /**
     * If defined, sets the maximum number of requests socket can handle.
     */
    maxRequestsPerSocket?: number;
}
export declare class Server extends EventEmitter {
    protected _netServer: any;
    protected _httpConnections: Set<Socket>;
    maxHeaderSize: number;
    maxRequestsPerSocket: number;
    headersTimeout: number;
    requestTimeout: number;
    keepAliveTimeout: number;
    constructor(options?: ServerOptions | ((req: IncomingMessage, res: ServerResponse) => void), requestListener?: (req: IncomingMessage, res: ServerResponse) => void);
    protected _setupHttpConnection(socket: Socket): void;
    listen(...args: any[]): this;
    close(callback?: (err?: Error) => void): this;
    [Symbol.asyncDispose](): Promise<void>;
    address(): {
        port: number;
        family: string;
        address: string;
    } | null;
    get listening(): boolean;
    setTimeout(ms: number, callback?: () => void): this;
}
export interface AgentOptions {
    keepAlive?: boolean;
    keepAliveMsecs?: number;
    maxSockets?: number;
    maxTotalSockets?: number;
    maxFreeSockets?: number;
    scheduling?: 'fifo' | 'lifo';
    timeout?: number;
    maxCachedSessions?: number;
}
export declare class Agent extends EventEmitter {
    maxSockets: number;
    maxTotalSockets: number;
    maxFreeSockets: number;
    keepAlive: boolean;
    keepAliveMsecs: number;
    maxCachedSessions: number;
    scheduling: 'fifo' | 'lifo';
    requests: Record<string, ClientRequest[]>;
    sockets: Record<string, Socket[]>;
    freeSockets: Record<string, Socket[]>;
    private _totalSockets;
    proxy: string | null;
    /**
     * Gets the proxy URL for the given request options.
     * Checks HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables.
     *
     * @param options Request options to determine if proxy should be used
     * @returns Proxy URL or null if no proxy should be used
     */
    protected getProxy(options: RequestOptions): string | null;
    constructor(options?: AgentOptions);
    getName(options: RequestOptions): string;
    addRequest(req: ClientRequest, options: RequestOptions): void;
    createConnection(options: RequestOptions, callback: (err: Error | null, socket: Socket) => void): Socket;
    releaseSocket(socket: Socket, options: RequestOptions): void;
    keepSocketAlive(_socket: Socket): boolean;
    reuseSocket(socket: Socket, req: ClientRequest): void;
    private _removeSocket;
    destroy(): void;
}
export declare const globalAgent: Agent;
export interface RequestOptions {
    protocol?: string;
    host?: string;
    hostname?: string;
    family?: number;
    port?: number;
    localAddress?: string;
    socketPath?: string;
    method?: string;
    path?: string;
    headers?: Record<string, any>;
    auth?: string;
    agent?: Agent | boolean;
    timeout?: number;
    rejectUnauthorized?: boolean;
}
export declare class ClientRequest extends OutgoingMessage {
    method: string;
    path: string;
    host: string;
    private _res?;
    private _options;
    private _connected;
    private _pendingWrites;
    private _ended;
    private _expectContinue;
    private _continueReceived;
    private _getChunkByteLength;
    private _getPendingBodyLength;
    constructor(options: RequestOptions, callback?: (res: IncomingMessage) => void);
    /** @internal */
    onSocket(socket: Socket | null): void;
    private _connect;
    private _attachSocketListeners;
    private _socketCleanup?;
    private _cleanupSocket;
    private _finishResponse;
    private _isFlushing;
    private _flushPendingWrites;
    private _finishRequest;
    private _sendRequest;
    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
    write(chunk: any, encoding?: any, callback?: any): boolean;
    end(chunk?: any, encoding?: any, callback?: any): this;
    abort(): void;
    flushHeaders(): void;
}
export declare function createServer(requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
export declare function createServer(options: ServerOptions, requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
export declare function request(urlOrOptions: string | URL | RequestOptions, optionsOrCallback?: RequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void): ClientRequest;
export declare function get(urlOrOptions: string | URL | RequestOptions, optionsOrCallback?: RequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void): ClientRequest;
//# sourceMappingURL=http.d.ts.map