react-native-nitro-net 0.2.0 → 0.3.1

package/README.md

@@ -1,15 +1,20 @@
 # react-native-nitro-net
 
-Node.js `net` API implementation for React Native using [Nitro Modules](https://github.com/mrousavy/nitro) and Rust.
+Ultra-high-performance networking to React Native by combining a memory-safe Rust core with the zero-overhead Nitro Modules JSI bridge. Provides Node.js-compatible net, tls, http(s) API.
+
+[![license](https://img.shields.io/badge/license-ISC-blue.svg)]()
+[![platform](https://img.shields.io/badge/platform-ios%20%7C%20android-lightgrey.svg)]()
+[![compatibility](https://img.shields.io/badge/Node.js-100%25%20dns-green.svg)]()
+[中文文档](./README_zh.md)
 
 ## Features
 
 *   🚀 **High Performance**: Built on top of Rust's `tokio` asynchronous runtime.
-*   🤝 **Node.js Compatible**: Implements standard `net` and `tls` APIs including `Socket`, `Server`, `TLSSocket`, and `SecureContext`.
+*   🤝 **Node.js Compatible**: Implements standard `net`, `tls`, `http`, and `https` APIs.
 *   🛡️ **Modern Security**: TLS implementation powered by **Rustls 0.23** (Ring provider), supporting TLS 1.2 and 1.3.
-*   🔒 **Full TLS Support**: Support for PEM/PFX certificates, encrypted private keys, SNI, Session tickets, and 100% Node.js API surface compatibility.
+*   🔒 **Full Protocol Support**: Support for PEM/PFX certificates, SNI, HTTP Trailers, 100 Continue, Protocol Upgrades (101), and HTTP Tunneling (CONNECT).
 *   ⚡ **Nitro Modules**: Uses JSI for zero-overhead communication between JavaScript and Native code.
-*   🛡️ **Robust & Stable**: Advanced fixes for port reuse, deadlocks, and DNS reliability.
+*   🛡️ **Robust & Stable**: Advanced fixes for port reuse, deadlocks, and connection pooling hangs.
 *   📱 **Cross-Platform**: Supports both iOS and Android.
 
 ## Installation
@@ -100,14 +105,66 @@ const server = tls.createServer({
 server.listen(443);
 ```
 
-## Stability Improvements
+*   **Advanced Features**: Supports `keylog` event re-emission for Wireshark, session resumption, and `asyncDispose`.
+*   **Performance Tuning**: Configurable `headersTimeout`, `keepAliveTimeout`, and `requestTimeout`.
+*   **Resource Management**: Strict protective shutdown logic in Rust to prevent socket and Unix domain socket file leaks.
+
+## Usage
 
-We have implemented several critical fixes to ensure production-grade stability:
+### HTTP Request
 
-*   **Port Reuse (`SO_REUSEPORT`)**: Automatically enabled on Unix/iOS to allow immediate server restarts without the "Address already in use" error.
-*   **Anti-Deadlock Logic**: C++ layer uses lock-free callback dispatching to prevent UI freezes during high-frequency events.
-*   **DNS Reliability**: Automatically retries all resolved IP addresses if the first one fails to connect.
-*   **Resource Management**: Strict protective shutdown logic in Rust to prevent socket and Unix domain socket file leaks.
+Implementation of the standard Node.js `http` API.
+
+```typescript
+import { http } from 'react-native-nitro-net';
+
+http.get('http://google.com', (res) => {
+  console.log(`Status: ${res.statusCode}`);
+  res.on('data', (chunk) => console.log(`Body segment: ${chunk.length} bytes`));
+  res.on('end', () => console.log('Request complete'));
+});
+```
+
+### HTTPS with Connection Pooling
+
+Uses `https` and the built-in `Agent` for connection reuse.
+
+```typescript
+import { https } from 'react-native-nitro-net';
+
+const agent = new https.Agent({ keepAlive: true });
+
+https.get('https://api.github.com/users/margelo', { agent }, (res) => {
+  // ... handle response
+});
+```
+
+### TCP Client (Socket)
+
+```typescript
+import net from 'react-native-nitro-net';
+
+const client = net.createConnection({ port: 8080, host: '127.0.0.1' }, () => {
+  client.write('Hello Server!');
+});
+```
+
+### Server (Dynamic Port Support)
+
+The server supports binding to a dynamic port by using `0`.
+
+```typescript
+import net from 'react-native-nitro-net';
+
+const server = net.createServer((socket) => {
+  socket.write('Echo: ' + socket.read());
+});
+
+server.listen(0, '127.0.0.1', () => {
+  const address = server.address();
+  console.log(`Server listening on dynamic port: ${address?.port}`);
+});
+```
 
 ## Compatibility Notes
 
@@ -147,7 +204,7 @@ We have implemented several critical fixes to ensure production-grade stability:
 
 | Method | Description |
 | --- | --- |
-| `initWithConfig(options)` | Optional. Initializes the Rust runtime with custom settings (e.g., `workerThreads`). Must be called before any other operation. |
+| `initWithConfig(options)` | Optional. Initializes the Rust runtime with custom settings (e.g., `workerThreads`, `debug`). Must be called before any other operation. |
 | `setVerbose(bool)` | Toggle detailed logging for JS, C++, and Rust. |
 | `isIP(string)` | Returns `0`, `4`, or `6`. |
 
@@ -159,8 +216,9 @@ We have implemented several critical fixes to ensure production-grade stability:
 | `close()` | Stops the server and **destroys all active connections**. |
 | `address()` | Returns the bound address (crucial for dynamic ports). |
 | `getConnections(cb)`| Get count of active connections. |
+| `renegotiate(opt, cb)`| **Shim**: Returns `ERR_TLS_RENEGOTIATION_DISABLED` (Rustls security policy). |
 
-**Events**: `listening`, `connection`, `error`, `close`.
+**Events**: `listening`, `connection`, `error`, `close`, `connect` (HTTP Tunneling).
 
 ### `tls.Server`
 *Extends `net.Server`*

package/cpp/HybridHttpParser.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "../nitrogen/generated/shared/c++/HybridHttpParserSpec.hpp"
+#include "NetBindings.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+
+namespace margelo {
+namespace nitro {
+namespace net {
+
+using namespace margelo::nitro;
+
+class HybridHttpParser : public HybridHttpParserSpec {
+public:
+  HybridHttpParser(int mode) : HybridObject(TAG) {
+    _id = net_http_parser_create(mode);
+  }
+
+  ~HybridHttpParser() { net_http_parser_destroy(_id); }
+
+  std::string feed(const std::shared_ptr<ArrayBuffer> &data) override {
+    if (!data)
+      return "";
+
+    char buf[4096];
+    int res =
+        net_http_parser_feed(_id, data->data(), data->size(), buf, sizeof(buf));
+
+    if (res > 0) {
+      // Complete message
+      return std::string(buf, res);
+    } else if (res == 0) {
+      // Partial message
+      return "";
+    } else if (res < -3) {
+      // Buffer too small, required size is -res
+      size_t requiredSize = static_cast<size_t>(-res);
+      std::string largerBuf(requiredSize, '\0');
+      res = net_http_parser_feed(_id, nullptr, 0, &largerBuf[0],
+                                 requiredSize + 1);
+      if (res > 0) {
+        return std::string(largerBuf.data(), res);
+      }
+      return "ERROR: Re-parse failed after enlarging buffer";
+    } else {
+      // Error
+      switch (res) {
+      case -1:
+        return "ERROR: JSON serialization failed";
+      case -2:
+        return "ERROR: HTTP parse failed";
+      case -3:
+        return "ERROR: Parser not found";
+      default:
+        return "ERROR: Unknown error";
+      }
+    }
+  }
+
+private:
+  uint32_t _id;
+};
+
+} // namespace net
+} // namespace nitro
+} // namespace margelo

package/cpp/HybridNetDriver.hpp

@@ -1,6 +1,8 @@
 #pragma once
 
+#include "../nitrogen/generated/shared/c++/HybridHttpParserSpec.hpp"
 #include "../nitrogen/generated/shared/c++/HybridNetDriverSpec.hpp"
+#include "HybridHttpParser.hpp"
 #include "HybridNetServerDriver.hpp"
 #include "HybridNetSocketDriver.hpp"
 #include "NetManager.hpp"
@@ -36,6 +38,10 @@ public:
     return std::make_shared<HybridNetServerDriver>();
   }
 
+  std::shared_ptr<HybridHttpParserSpec> createHttpParser(double mode) override {
+    return std::make_shared<HybridHttpParser>(static_cast<int>(mode));
+  }
+
   double
   createSecureContext(const std::string &cert, const std::string &key,
                       const std::optional<std::string> &passphrase) override {

package/cpp/HybridNetServerDriver.hpp

@@ -63,6 +63,13 @@ public:
     net_listen_unix(_id, path.c_str(), static_cast<int>(backlog.value_or(128)));
   }
 
+  void listenTLSUnix(const std::string &path, double secureContextId,
+                     std::optional<double> backlog) override {
+    net_listen_tls_unix(_id, path.c_str(),
+                        static_cast<int>(backlog.value_or(128)),
+                        static_cast<uint32_t>(secureContextId));
+  }
+
   void listenHandle(double fd, std::optional<double> backlog) override {
     net_listen_handle(_id, static_cast<int>(fd),
                       static_cast<int>(backlog.value_or(128)));

package/cpp/HybridNetSocketDriver.hpp

@@ -4,8 +4,10 @@
 #include "NetBindings.hpp"
 #include "NetManager.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace margelo {
 namespace nitro {
@@ -180,6 +182,31 @@ public:
 
   void enableKeylog() override { net_socket_enable_keylog(_id); }
 
+  void enableTrace() override { net_socket_enable_trace(_id); }
+
+  std::optional<std::shared_ptr<ArrayBuffer>> exportKeyingMaterial(
+      double length, const std::string &label,
+      const std::optional<std::shared_ptr<ArrayBuffer>> &context) override {
+    size_t len = static_cast<size_t>(length);
+    std::vector<uint8_t> output(len);
+
+    const uint8_t *ctx_data = nullptr;
+    size_t ctx_len = 0;
+    if (context.has_value() && context.value()) {
+      ctx_data = context.value()->data();
+      ctx_len = context.value()->size();
+    }
+
+    int result = net_socket_export_keying_material(
+        _id, len, label.c_str(), ctx_data, ctx_len, output.data(),
+        output.size());
+
+    if (result > 0) {
+      return ArrayBuffer::copy(output.data(), static_cast<size_t>(result));
+    }
+    return std::nullopt;
+  }
+
   void setNoDelay(bool enable) override { net_set_nodelay(_id, enable); }
 
   void setKeepAlive(bool enable, double delay) override {

package/cpp/NetBindings.hpp

@@ -42,6 +42,13 @@ void net_socket_reset_and_destroy(uint32_t id);
 size_t net_get_ephemeral_key_info(uint32_t id, char *buf, size_t len);
 size_t net_get_shared_sigalgs(uint32_t id, char *buf, size_t len);
 
+// TLS Features: enableTrace and exportKeyingMaterial
+void net_socket_enable_trace(uint32_t id);
+int net_socket_export_keying_material(uint32_t id, size_t length,
+                                      const char *label, const uint8_t *context,
+                                      size_t context_len, uint8_t *buf,
+                                      size_t buf_len);
+
 // New Options
 void net_set_nodelay(uint32_t id, bool enable);
 void net_set_keepalive(uint32_t id, bool enable, uint64_t delay_ms);
@@ -60,6 +67,8 @@ void net_shutdown(uint32_t id);
 // IPC / Unix Domain Sockets
 void net_connect_unix(uint32_t id, const char *path);
 void net_listen_unix(uint32_t id, const char *path, int backlog);
+void net_listen_tls_unix(uint32_t id, const char *path, int backlog,
+                         uint32_t secure_context_id);
 
 #if !defined(__ANDROID__)
 // Unix-only TLS functions (not available on Android)
@@ -108,6 +117,12 @@ void net_set_session(uint32_t id, const uint8_t *ticket, size_t ticket_len);
 size_t net_server_get_ticket_keys(uint32_t id, uint8_t *buf, size_t len);
 void net_server_set_ticket_keys(uint32_t id, const uint8_t *keys, size_t len);
 
+// HTTP Parser
+uint32_t net_http_parser_create(int mode);
+int net_http_parser_feed(uint32_t id, const uint8_t *data, size_t len,
+                         char *buf, size_t buf_len);
+void net_http_parser_destroy(uint32_t id);
+
 // Event Types
 #define NET_EVENT_CONNECT 1
 #define NET_EVENT_DATA 2

package/ios/Frameworks/RustCNet.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>RustCNet.framework/RustCNet</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>RustCNet.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>RustCNet.framework/RustCNet</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>RustCNet.framework</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/lib/Driver.d.ts

@@ -1,2 +1,3 @@
 import type { NetDriver } from './Net.nitro';
 export declare const Driver: NetDriver;
+//# sourceMappingURL=Driver.d.ts.map

package/lib/Driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Driver.d.ts","sourceRoot":"","sources":["../src/Driver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAE5C,eAAO,MAAM,MAAM,WAA0D,CAAA"}

package/lib/Driver.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Driver = void 0;
-const react_native_nitro_modules_1 = require("react-native-nitro-modules");
-exports.Driver = react_native_nitro_modules_1.NitroModules.createHybridObject('NetDriver');
+import { NitroModules } from 'react-native-nitro-modules';
+export const Driver = NitroModules.createHybridObject('NetDriver');

package/lib/Net.nitro.d.ts

@@ -48,6 +48,8 @@ export interface NetSocketDriver extends HybridObject<{
     destroy(): void;
     resetAndDestroy(): void;
     enableKeylog(): void;
+    enableTrace(): void;
+    exportKeyingMaterial(length: number, label: string, context?: ArrayBuffer): ArrayBuffer | undefined;
     setNoDelay(enable: boolean): void;
     setKeepAlive(enable: boolean, delay: number): void;
     getLocalAddress(): string;
@@ -68,6 +70,7 @@ export interface NetServerDriver extends HybridObject<{
     listen(port: number, backlog?: number, ipv6Only?: boolean, reusePort?: boolean): void;
     listenTLS(port: number, secureContextId: number, backlog?: number, ipv6Only?: boolean, reusePort?: boolean): void;
     listenUnix(path: string, backlog?: number): void;
+    listenTLSUnix(path: string, secureContextId: number, backlog?: number): void;
     /**
      * Listen on an existing file descriptor (handle)
      * @param fd File descriptor of an already-bound TCP listener
@@ -78,6 +81,17 @@ export interface NetServerDriver extends HybridObject<{
     maxConnections: number;
     close(): void;
 }
+export interface HttpParser extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Feed data to the parser
+     * @param data Raw byte data from the network
+     * @returns JSON string of the parsed message if complete, empty string if partial, or error message starting with 'ERROR:'
+     */
+    feed(data: ArrayBuffer): string;
+}
 /**
  * Runtime configuration for the network module
  */
@@ -87,6 +101,10 @@ export interface NetConfig {
      * 0 = use CPU core count (default)
      */
     workerThreads?: number;
+    /**
+     * Whether to enable verbose debug logging
+     */
+    debug?: boolean;
 }
 export interface NetDriver extends HybridObject<{
     ios: 'swift';
@@ -94,6 +112,7 @@ export interface NetDriver extends HybridObject<{
 }> {
     createSocket(id?: string): NetSocketDriver;
     createServer(): NetServerDriver;
+    createHttpParser(mode: number): HttpParser;
     createSecureContext(cert: string, key: string, passphrase?: string): number;
     createEmptySecureContext(): number;
     addCACertToSecureContext(scId: number, ca: string): void;
@@ -109,3 +128,4 @@ export interface NetDriver extends HybridObject<{
      */
     initWithConfig(config: NetConfig): void;
 }
+//# sourceMappingURL=Net.nitro.d.ts.map

package/lib/Net.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Net.nitro.d.ts","sourceRoot":"","sources":["../src/Net.nitro.ts"],"names":[],"mappings":"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"}

package/lib/Net.nitro.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetServerEvent = exports.NetSocketEvent = void 0;
-var NetSocketEvent;
+export var NetSocketEvent;
 (function (NetSocketEvent) {
     NetSocketEvent[NetSocketEvent["CONNECT"] = 1] = "CONNECT";
     NetSocketEvent[NetSocketEvent["DATA"] = 2] = "DATA";
@@ -13,11 +10,11 @@ var NetSocketEvent;
     NetSocketEvent[NetSocketEvent["SESSION"] = 9] = "SESSION";
     NetSocketEvent[NetSocketEvent["KEYLOG"] = 10] = "KEYLOG";
     NetSocketEvent[NetSocketEvent["OCSP"] = 11] = "OCSP";
-})(NetSocketEvent || (exports.NetSocketEvent = NetSocketEvent = {}));
-var NetServerEvent;
+})(NetSocketEvent || (NetSocketEvent = {}));
+export var NetServerEvent;
 (function (NetServerEvent) {
     NetServerEvent[NetServerEvent["CONNECTION"] = 6] = "CONNECTION";
     NetServerEvent[NetServerEvent["ERROR"] = 3] = "ERROR";
     NetServerEvent[NetServerEvent["CLOSE"] = 4] = "CLOSE";
     NetServerEvent[NetServerEvent["DEBUG"] = 9] = "DEBUG";
-})(NetServerEvent || (exports.NetServerEvent = NetServerEvent = {}));
+})(NetServerEvent || (NetServerEvent = {}));

package/lib/http.d.ts

@@ -0,0 +1,204 @@
+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;
+    constructor(options: RequestOptions, callback?: (res: IncomingMessage) => void);
+    /** @internal */
+    onSocket(socket: Socket | null): void;
+    private _connect;
+    private _attachSocketListeners;
+    private _socketCleanup?;
+    private _cleanupSocket;
+    private _finishResponse;
+    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