rezo 1.0.2 → 1.0.4

package/dist/adapters/entries/http2.d.ts

@@ -1,4 +1,5 @@
 import NodeFormData from 'form-data';
+import { Blob as Blob$1 } from 'node:buffer';
 import { EventEmitter } from 'node:events';
 import { Agent as HttpAgent, OutgoingHttpHeaders } from 'node:http';
 import { Agent as HttpsAgent } from 'node:https';
@@ -103,7 +104,7 @@ export type RezoHeadersInit = [
 	string,
 	string
 ][] | Record<string, string> | Headers | RezoHttpHeaders | RezoHeaders | OutgoingHttpHeaders;
-declare class RezoHeaders extends Headers {
+export declare class RezoHeaders extends Headers {
 	constructor(init?: RezoHeadersInit);
 	getAll(name: "set-cookie" | "Set-Cookie"): string[];
 	getSetCookie(): string[];
@@ -193,7 +194,7 @@ declare class Cookie extends TouchCookie {
 	 */
 	static isCookie(cookie: any): cookie is Cookie;
 }
-declare class RezoCookieJar extends TouchCookieJar {
+export declare class RezoCookieJar extends TouchCookieJar {
 	constructor();
 	constructor(cookies: Cookie[]);
 	constructor(cookies: Cookie[], url: string);
@@ -282,7 +283,7 @@ export interface Options extends ReadableOptions {
 	maxDataSize?: number;
 	pauseStreams?: boolean;
 }
-declare class RezoFormData extends NodeFormData {
+export declare class RezoFormData extends NodeFormData {
 	constructor(options?: Options);
 	/**
 	 * Get field entries as array of [name, value] pairs
@@ -898,6 +899,292 @@ export interface RezoDownloadResponse extends DownloadResponse {
  */
 export interface RezoUploadResponse extends UploadResponse {
 }
+/**
+ * Rezo ProxyManager Types
+ * Type definitions for advanced proxy rotation and management
+ *
+ * @module proxy/types
+ * @author Yuniq Solutions Team
+ * @version 1.0.0
+ */
+/** Supported proxy protocols */
+export type ProxyProtocol = "socks4" | "socks5" | "http" | "https";
+/**
+ * Proxy information structure
+ * Represents a single proxy server with its connection details
+ */
+export interface ProxyInfo {
+	/** Unique identifier for the proxy (auto-generated if not provided) */
+	id?: string;
+	/** The proxy protocol to use */
+	protocol: ProxyProtocol;
+	/** Proxy server hostname or IP address */
+	host: string;
+	/** Proxy server port number */
+	port: number;
+	/** Optional authentication credentials for the proxy */
+	auth?: {
+		/** Username for proxy authentication */
+		username: string;
+		/** Password for proxy authentication */
+		password: string;
+	};
+	/** Optional label for identification/logging */
+	label?: string;
+	/** Optional metadata for custom tracking */
+	metadata?: Record<string, unknown>;
+}
+/**
+ * Proxy rotation strategies
+ * - `random`: Select a random proxy from the pool for each request
+ * - `sequential`: Use proxies in order, optionally rotating after N requests
+ * - `per-proxy-limit`: Use each proxy for a maximum number of requests, then permanently remove
+ */
+export type RotationStrategy = "random" | "sequential" | "per-proxy-limit";
+/**
+ * Rotation configuration for different strategies
+ */
+export type RotationConfig = {
+	/** Random selection from available proxies */
+	rotation: "random";
+} | {
+	/** Sequential rotation through proxy list */
+	rotation: "sequential";
+	/** Number of requests before rotating to next proxy (default: 1) */
+	requestsPerProxy?: number;
+} | {
+	/** Use each proxy for a limited number of total requests, then remove */
+	rotation: "per-proxy-limit";
+	/** Maximum requests per proxy before permanent removal */
+	limit: number;
+};
+/**
+ * Cooldown configuration for disabled proxies
+ */
+export interface ProxyCooldownConfig {
+	/** Whether to enable automatic re-enabling after cooldown */
+	enabled: boolean;
+	/** Duration in milliseconds before re-enabling a disabled proxy */
+	durationMs: number;
+}
+/**
+ * Base proxy manager configuration (without rotation)
+ * Complete configuration for proxy rotation, filtering, and failure handling
+ */
+export interface ProxyManagerBaseConfig {
+	/** Array of proxies to manage */
+	proxies: ProxyInfo[];
+	/**
+	 * Whitelist patterns for URLs that should use proxy
+	 * - String: exact domain match (e.g., 'api.example.com') or subdomain match (e.g., 'example.com' matches '*.example.com')
+	 * - RegExp: regex pattern to test against full URL
+	 * If not set, all URLs use proxy
+	 */
+	whitelist?: (string | RegExp)[];
+	/**
+	 * Blacklist patterns for URLs that should NOT use proxy (go direct)
+	 * - String: exact domain match or subdomain match
+	 * - RegExp: regex pattern to test against full URL
+	 * Blacklist is checked after whitelist
+	 */
+	blacklist?: (string | RegExp)[];
+	/**
+	 * Automatically disable proxies after consecutive failures
+	 * @default false
+	 */
+	autoDisableDeadProxies?: boolean;
+	/**
+	 * Number of consecutive failures before disabling a proxy
+	 * Only applies when autoDisableDeadProxies is true
+	 * @default 3
+	 */
+	maxFailures?: number;
+	/**
+	 * Cooldown configuration for disabled proxies
+	 * If not set or enabled: false, proxies are permanently removed when disabled
+	 */
+	cooldown?: ProxyCooldownConfig;
+	/**
+	 * Whether to throw error when no proxy is available
+	 * - true (default): Throw RezoError when no proxies available
+	 * - false: Proceed with direct connection (no proxy)
+	 * @default true
+	 */
+	failWithoutProxy?: boolean;
+	/**
+	 * Whether to retry the request with next proxy on failure
+	 * @default false
+	 */
+	retryWithNextProxy?: boolean;
+	/**
+	 * Maximum retry attempts when retryWithNextProxy is enabled
+	 * @default 3
+	 */
+	maxProxyRetries?: number;
+}
+/**
+ * Full proxy manager configuration
+ * Combines base config with rotation strategy
+ */
+export type ProxyManagerConfig = ProxyManagerBaseConfig & RotationConfig;
+/**
+ * Internal proxy state tracking
+ * Used internally by ProxyManager to track usage and failures
+ */
+export interface ProxyState {
+	/** The proxy info */
+	proxy: ProxyInfo;
+	/** Number of requests made through this proxy */
+	requestCount: number;
+	/** Number of consecutive failures */
+	failureCount: number;
+	/** Total number of successful requests */
+	successCount: number;
+	/** Total number of failed requests */
+	totalFailures: number;
+	/** Whether the proxy is currently active */
+	isActive: boolean;
+	/** Reason for being disabled (if applicable) */
+	disabledReason?: "dead" | "limit-reached" | "manual";
+	/** Timestamp when proxy was disabled */
+	disabledAt?: number;
+	/** Timestamp when proxy will be re-enabled (if cooldown enabled) */
+	reenableAt?: number;
+	/** Last successful request timestamp */
+	lastSuccessAt?: number;
+	/** Last failure timestamp */
+	lastFailureAt?: number;
+	/** Last error message */
+	lastError?: string;
+}
+/**
+ * Proxy manager status snapshot
+ * Provides overview of all proxies in the manager
+ */
+export interface ProxyManagerStatus {
+	/** Active proxies available for use */
+	active: ProxyInfo[];
+	/** Disabled proxies (dead or limit reached) */
+	disabled: ProxyInfo[];
+	/** Proxies in cooldown waiting to be re-enabled */
+	cooldown: ProxyInfo[];
+	/** Total number of proxies */
+	total: number;
+	/** Current rotation strategy */
+	rotation: RotationStrategy;
+	/** Total requests made through the manager */
+	totalRequests: number;
+	/** Total successful requests */
+	totalSuccesses: number;
+	/** Total failed requests */
+	totalFailures: number;
+}
+/**
+ * Result from proxy selection
+ */
+export interface ProxySelectionResult {
+	/** Selected proxy (null if should go direct) */
+	proxy: ProxyInfo | null;
+	/** Reason for selection result */
+	reason: "selected" | "whitelist-no-match" | "blacklist-match" | "no-proxies-available" | "disabled";
+}
+/**
+ * Context for beforeProxySelect hook
+ */
+export interface BeforeProxySelectContext {
+	/** Request URL */
+	url: string;
+	/** Available active proxies */
+	proxies: ProxyInfo[];
+	/** Whether this is a retry attempt */
+	isRetry: boolean;
+	/** Retry count (0 for initial request) */
+	retryCount: number;
+}
+/**
+ * Context for afterProxySelect hook
+ */
+export interface AfterProxySelectContext {
+	/** Request URL */
+	url: string;
+	/** Selected proxy (null if going direct) */
+	proxy: ProxyInfo | null;
+	/** Selection reason */
+	reason: ProxySelectionResult["reason"];
+}
+/**
+ * Context for beforeProxyError hook
+ */
+export interface BeforeProxyErrorContext {
+	/** The proxy that failed */
+	proxy: ProxyInfo;
+	/** The error that occurred */
+	error: Error;
+	/** Request URL */
+	url: string;
+	/** Current failure count for this proxy */
+	failureCount: number;
+	/** Whether proxy will be disabled after this error */
+	willBeDisabled: boolean;
+}
+/**
+ * Context for afterProxyError hook
+ */
+export interface AfterProxyErrorContext {
+	/** The proxy that failed */
+	proxy: ProxyInfo;
+	/** The error that occurred */
+	error: Error;
+	/** Action taken after error */
+	action: "retry-next-proxy" | "disabled" | "continue";
+	/** Next proxy for retry (if action is 'retry-next-proxy') */
+	nextProxy?: ProxyInfo;
+}
+/**
+ * Context for beforeProxyDisable hook
+ * Return false to prevent disabling
+ */
+export interface BeforeProxyDisableContext {
+	/** The proxy about to be disabled */
+	proxy: ProxyInfo;
+	/** Reason for disabling */
+	reason: "dead" | "limit-reached" | "manual";
+	/** Current proxy state */
+	state: ProxyState;
+}
+/**
+ * Context for afterProxyDisable hook
+ */
+export interface AfterProxyDisableContext {
+	/** The proxy that was disabled */
+	proxy: ProxyInfo;
+	/** Reason for disabling */
+	reason: "dead" | "limit-reached" | "manual";
+	/** Whether cooldown is enabled for re-enabling */
+	hasCooldown: boolean;
+	/** Timestamp when proxy will be re-enabled (if cooldown enabled) */
+	reenableAt?: number;
+}
+/**
+ * Context for afterProxyRotate hook
+ */
+export interface AfterProxyRotateContext {
+	/** Previous proxy (null if first selection) */
+	from: ProxyInfo | null;
+	/** New proxy */
+	to: ProxyInfo;
+	/** Reason for rotation */
+	reason: "scheduled" | "failure" | "limit-reached";
+}
+/**
+ * Context for afterProxyEnable hook
+ */
+export interface AfterProxyEnableContext {
+	/** The proxy that was enabled */
+	proxy: ProxyInfo;
+	/** Reason for enabling */
+	reason: "cooldown-expired" | "manual";
+}
 /**
  * Context provided to beforeRequest hook
  * Contains metadata about the current request state
@@ -1176,6 +1463,46 @@ export type OnTimeoutHook = (event: TimeoutEvent, config: RezoConfig) => void;
  * Use for cleanup, logging
  */
 export type OnAbortHook = (event: AbortEvent, config: RezoConfig) => void;
+/**
+ * Hook called before a proxy is selected
+ * Can return a specific proxy to override selection
+ */
+export type BeforeProxySelectHook = (context: BeforeProxySelectContext) => ProxyInfo | void | Promise<ProxyInfo | void>;
+/**
+ * Hook called after a proxy is selected
+ * Use for logging, analytics
+ */
+export type AfterProxySelectHook = (context: AfterProxySelectContext) => void | Promise<void>;
+/**
+ * Hook called before a proxy error is processed
+ * Use for error inspection, custom handling
+ */
+export type BeforeProxyErrorHook = (context: BeforeProxyErrorContext) => void | Promise<void>;
+/**
+ * Hook called after a proxy error is processed
+ * Use for error logging, fallback logic
+ */
+export type AfterProxyErrorHook = (context: AfterProxyErrorContext) => void | Promise<void>;
+/**
+ * Hook called before a proxy is disabled
+ * Return false to prevent disabling
+ */
+export type BeforeProxyDisableHook = (context: BeforeProxyDisableContext) => boolean | void | Promise<boolean | void>;
+/**
+ * Hook called after a proxy is disabled
+ * Use for notifications, logging
+ */
+export type AfterProxyDisableHook = (context: AfterProxyDisableContext) => void | Promise<void>;
+/**
+ * Hook called when proxy rotation occurs
+ * Use for monitoring rotation patterns
+ */
+export type AfterProxyRotateHook = (context: AfterProxyRotateContext) => void | Promise<void>;
+/**
+ * Hook called when a proxy is re-enabled
+ * Use for notifications, logging
+ */
+export type AfterProxyEnableHook = (context: AfterProxyEnableContext) => void | Promise<void>;
 /**
  * Collection of all hook types
  * All hooks are arrays to allow multiple handlers
@@ -1192,12 +1519,29 @@ export interface RezoHooks {
 	afterParse: AfterParseHook[];
 	beforeCookie: BeforeCookieHook[];
 	afterCookie: AfterCookieHook[];
+	beforeProxySelect: BeforeProxySelectHook[];
+	afterProxySelect: AfterProxySelectHook[];
+	beforeProxyError: BeforeProxyErrorHook[];
+	afterProxyError: AfterProxyErrorHook[];
+	beforeProxyDisable: BeforeProxyDisableHook[];
+	afterProxyDisable: AfterProxyDisableHook[];
+	afterProxyRotate: AfterProxyRotateHook[];
+	afterProxyEnable: AfterProxyEnableHook[];
 	onSocket: OnSocketHook[];
 	onDns: OnDnsHook[];
 	onTls: OnTlsHook[];
 	onTimeout: OnTimeoutHook[];
 	onAbort: OnAbortHook[];
 }
+/**
+ * Create empty hooks object with all arrays initialized
+ */
+export declare function createDefaultHooks(): RezoHooks;
+/**
+ * Merge base hooks with override hooks
+ * Overrides are appended to base hooks (base runs first)
+ */
+export declare function mergeHooks(base: RezoHooks, overrides?: Partial<RezoHooks>): RezoHooks;
 /**
  * Configuration object that encapsulates comprehensive request execution metadata and response processing information.
  * This interface serves as the central configuration hub for HTTP requests, containing both input parameters
@@ -1539,7 +1883,58 @@ export interface RezoConfig {
 	 */
 	useCookies: boolean;
 }
-declare class RezoError<T = any> extends Error {
+export declare enum RezoErrorCode {
+	CONNECTION_REFUSED = "ECONNREFUSED",
+	CONNECTION_RESET = "ECONNRESET",
+	CONNECTION_TIMEOUT = "ETIMEDOUT",
+	DNS_LOOKUP_FAILED = "ENOTFOUND",
+	DNS_TEMPORARY_FAILURE = "EAI_AGAIN",
+	HOST_UNREACHABLE = "EHOSTUNREACH",
+	NETWORK_UNREACHABLE = "ENETUNREACH",
+	BROKEN_PIPE = "EPIPE",
+	HTTP_ERROR = "REZ_HTTP_ERROR",
+	REDIRECT_DENIED = "REZ_REDIRECT_DENIED",
+	MAX_REDIRECTS = "REZ_MAX_REDIRECTS_EXCEEDED",
+	REDIRECT_CYCLE = "REZ_REDIRECT_CYCLE_DETECTED",
+	MISSING_REDIRECT_LOCATION = "REZ_MISSING_REDIRECT_LOCATION",
+	DECOMPRESSION_ERROR = "REZ_DECOMPRESSION_ERROR",
+	REQUEST_TIMEOUT = "UND_ERR_REQUEST_TIMEOUT",
+	HEADERS_TIMEOUT = "UND_ERR_HEADERS_TIMEOUT",
+	CONNECT_TIMEOUT = "UND_ERR_CONNECT_TIMEOUT",
+	ABORTED = "ABORT_ERR",
+	DOWNLOAD_FAILED = "REZ_DOWNLOAD_FAILED",
+	UPLOAD_FAILED = "REZ_UPLOAD_FAILED",
+	STREAM_ERROR = "REZ_STREAM_ERROR",
+	BODY_TOO_LARGE = "REZ_BODY_TOO_LARGE",
+	RESPONSE_TOO_LARGE = "REZ_RESPONSE_TOO_LARGE",
+	INVALID_JSON = "REZ_INVALID_JSON",
+	INVALID_URL = "ERR_INVALID_URL",
+	INVALID_PROTOCOL = "ERR_INVALID_PROTOCOL",
+	INVALID_ARGUMENT = "ERR_INVALID_ARG_TYPE",
+	FILE_PERMISSION = "REZ_FILE_PERMISSION_ERROR",
+	PROXY_CONNECTION_FAILED = "REZ_PROXY_CONNECTION_FAILED",
+	PROXY_AUTH_FAILED = "REZ_PROXY_AUTHENTICATION_FAILED",
+	PROXY_TARGET_UNREACHABLE = "REZ_PROXY_TARGET_UNREACHABLE",
+	PROXY_TIMEOUT = "REZ_PROXY_TIMEOUT",
+	PROXY_ERROR = "REZ_PROXY_ERROR",
+	PROXY_INVALID_PROTOCOL = "REZ_PROXY_INVALID_PROTOCOL",
+	PROXY_INVALID_CONFIG = "REZ_PROXY_INVALID_HOSTPORT",
+	SOCKS_CONNECTION_FAILED = "REZ_SOCKS_CONNECTION_FAILED",
+	SOCKS_AUTH_FAILED = "REZ_SOCKS_AUTHENTICATION_FAILED",
+	SOCKS_TARGET_UNREACHABLE = "REZ_SOCKS_TARGET_CONNECTION_FAILED",
+	SOCKS_PROTOCOL_ERROR = "REZ_SOCKS_PROTOCOL_ERROR",
+	SOCKS_UNSUPPORTED_VERSION = "REZ_SOCKS_UNSUPPORTED_VERSION",
+	TLS_HANDSHAKE_TIMEOUT = "ERR_TLS_HANDSHAKE_TIMEOUT",
+	TLS_PROTOCOL_ERROR = "EPROTO",
+	TLS_PROTOCOL_VERSION = "ERR_TLS_INVALID_PROTOCOL_VERSION",
+	CERTIFICATE_HOSTNAME_MISMATCH = "ERR_TLS_CERT_ALTNAME_INVALID",
+	CERTIFICATE_EXPIRED = "CERT_HAS_EXPIRED",
+	CERTIFICATE_SELF_SIGNED = "SELF_SIGNED_CERT_IN_CHAIN",
+	CERTIFICATE_VERIFY_FAILED = "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+	RATE_LIMITED = "REZ_RATE_LIMITED",
+	UNKNOWN_ERROR = "REZ_UNKNOWN_ERROR"
+}
+export declare class RezoError<T = any> extends Error {
 	readonly code?: string;
 	readonly errno?: number;
 	readonly config: RezoConfig;
@@ -1588,16 +1983,13 @@ declare class RezoError<T = any> extends Error {
 	toString(): string;
 	getFullDetails(): string;
 }
-/**
- * Supported proxy protocols for network requests
- */
-export type ProxyProtocol = "http" | "https" | "socks4" | "socks5";
+type ProxyProtocol$1 = "http" | "https" | "socks4" | "socks5";
 /**
  * Configuration options for proxy connections
  */
 export type ProxyOptions = {
 	/** The proxy protocol to use */
-	protocol: ProxyProtocol;
+	protocol: ProxyProtocol$1;
 	/** Proxy server hostname or IP address */
 	host: string;
 	/** Proxy server port number */
@@ -1638,6 +2030,51 @@ export type RezoString = string;
  * Standard HTTP methods supported by Rezo
  */
 export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT";
+/**
+ * Response data types that control how Rezo parses the response body.
+ *
+ * @description
+ * Specifies how the response body should be parsed and returned in `response.data`.
+ * Choose the type that matches your expected response format.
+ *
+ * **Available Types:**
+ *
+ * - `'json'` - Parse response as JSON. Returns parsed object/array.
+ *   Best for REST APIs that return JSON data.
+ *
+ * - `'text'` - Return response as a string. No parsing applied.
+ *   Best for HTML, XML, plain text, or when you need raw content.
+ *
+ * - `'blob'` - Return as Blob object (browser environments).
+ *   Best for binary data in browsers (images, files, etc).
+ *
+ * - `'arrayBuffer'` - Return as ArrayBuffer.
+ *   Best for binary data processing, cryptographic operations.
+ *
+ * - `'buffer'` - Return as Node.js Buffer.
+ *   Best for binary data in Node.js (files, images, binary protocols).
+ *
+ * - `'auto'` - Auto-detect based on Content-Type header (default).
+ *   JSON for `application/json`, text for `text/*`, buffer otherwise.
+ *
+ * **Streaming Operations:**
+ * For streaming, use dedicated methods instead of responseType:
+ * - `rezo.stream(url)` - Returns StreamResponse for real-time data
+ * - `rezo.download(url, saveTo)` - Returns DownloadResponse with progress
+ * - `rezo.upload(url, data)` - Returns UploadResponse with progress
+ *
+ * @example
+ * // Get JSON data (default for JSON APIs)
+ * const { data } = await rezo.get('/api/users', { responseType: 'json' });
+ *
+ * // Get HTML as text
+ * const { data: html } = await rezo.get('/page', { responseType: 'text' });
+ *
+ * // Get image as buffer
+ * const { data: imageBuffer } = await rezo.get('/image.png', { responseType: 'buffer' });
+ *
+ * @default 'auto'
+ */
 type ResponseType$1 = "json" | "text" | "blob" | "arrayBuffer" | "buffer" | "auto";
 /**
  * MIME content types for request/response bodies
@@ -1972,11 +2409,81 @@ export type ToRedirectOptions = {
  * @internal - Do not use internally within the library
  */
 export type RezoHttpRequest = Omit<RezoRequestConfig, "body" | "url" | "method" | "form" | "json" | "formData" | "multipart" | "fullUrl" | "responseType">;
+/**
+ * Method-aware request types for better TypeScript inference
+ * These types remove data/body fields from methods that don't typically use them
+ */
+/**
+ * RezoHttpGetRequest - Request options for GET requests (no request body)
+ * @public - Use with GET method
+ */
+export type RezoHttpGetRequest = Omit<RezoHttpRequest, "data" | "body">;
+/**
+ * RezoHttpPostRequest - Request options for POST requests (includes request body)
+ * @public - Use with POST method
+ */
+export type RezoHttpPostRequest = RezoHttpRequest;
+/**
+ * RezoHttpPutRequest - Request options for PUT requests (includes request body)
+ * @public - Use with PUT method
+ */
+export type RezoHttpPutRequest = RezoHttpRequest;
+/**
+ * RezoHttpPatchRequest - Request options for PATCH requests (includes request body)
+ * @public - Use with PATCH method
+ */
+export type RezoHttpPatchRequest = RezoHttpRequest;
+/**
+ * RezoHttpDeleteRequest - Request options for DELETE requests (no request body)
+ * @public - Use with DELETE method
+ */
+export type RezoHttpDeleteRequest = Omit<RezoHttpRequest, "data" | "body">;
+/**
+ * RezoHttpHeadRequest - Request options for HEAD requests (no request body)
+ * @public - Use with HEAD method
+ */
+export type RezoHttpHeadRequest = Omit<RezoHttpRequest, "data" | "body">;
+/**
+ * RezoHttpOptionsRequest - Request options for OPTIONS requests (no request body)
+ * @public - Use with OPTIONS method
+ */
+export type RezoHttpOptionsRequest = Omit<RezoHttpRequest, "data" | "body">;
+/**
+ * RezoRequestOptions - Request configuration type for the .request() method
+ *
+ * This type excludes internal properties and is specifically designed for public API usage.
+ * Use this type when creating reusable request configurations for the .request() method.
+ *
+ * @public - For external use with .request() method only
+ * @internal - Do not use internally within the library
+ */
+export type RezoRequestOptions = Omit<RezoRequestConfig, "fullUrl">;
 export interface DNSCacheOptions {
 	enable?: boolean;
 	ttl?: number;
 	maxEntries?: number;
 }
+declare class DNSCache {
+	private cache;
+	private enabled;
+	constructor(options?: DNSCacheOptions);
+	private makeKey;
+	lookup(hostname: string, family?: 4 | 6): Promise<{
+		address: string;
+		family: 4 | 6;
+	} | undefined>;
+	lookupAll(hostname: string, family?: 4 | 6): Promise<Array<{
+		address: string;
+		family: 4 | 6;
+	}>>;
+	private resolveDNS;
+	private resolveAllDNS;
+	invalidate(hostname: string): void;
+	clear(): void;
+	get size(): number;
+	get isEnabled(): boolean;
+	setEnabled(enabled: boolean): void;
+}
 export interface ResponseCacheConfig {
 	enable?: boolean;
 	cacheDir?: string;
@@ -1986,6 +2493,201 @@ export interface ResponseCacheConfig {
 	methods?: string[];
 	respectHeaders?: boolean;
 }
+export type ResponseCacheOption = boolean | ResponseCacheConfig;
+export interface CachedResponse {
+	status: number;
+	statusText: string;
+	headers: Record<string, string>;
+	data: unknown;
+	url: string;
+	timestamp: number;
+	ttl: number;
+	etag?: string;
+	lastModified?: string;
+}
+declare class ResponseCache {
+	private memoryCache;
+	private config;
+	private persistenceEnabled;
+	private initialized;
+	constructor(options?: ResponseCacheOption);
+	private initializePersistence;
+	private initializePersistenceAsync;
+	private getCacheFilePath;
+	private persistToDisk;
+	private loadFromDiskAsync;
+	private generateKey;
+	private parseCacheControl;
+	isCacheable(method: string, status: number, headers?: Record<string, string>): boolean;
+	get(method: string, url: string, headers?: Record<string, string>): CachedResponse | undefined;
+	private loadSingleFromDisk;
+	set(method: string, url: string, response: RezoResponse, requestHeaders?: Record<string, string>): void;
+	private normalizeHeaders;
+	getConditionalHeaders(method: string, url: string, requestHeaders?: Record<string, string>): Record<string, string> | undefined;
+	updateRevalidated(method: string, url: string, newHeaders: Record<string, string>, requestHeaders?: Record<string, string>): CachedResponse | undefined;
+	invalidate(url: string, method?: string): void;
+	clear(): void;
+	get size(): number;
+	get isEnabled(): boolean;
+	get isPersistent(): boolean;
+	getConfig(): ResponseCacheConfig;
+}
+type BeforeProxySelectHook$1 = (context: BeforeProxySelectContext) => ProxyInfo | void | Promise<ProxyInfo | void>;
+type AfterProxySelectHook$1 = (context: AfterProxySelectContext) => void | Promise<void>;
+type BeforeProxyErrorHook$1 = (context: BeforeProxyErrorContext) => void | Promise<void>;
+type AfterProxyErrorHook$1 = (context: AfterProxyErrorContext) => void | Promise<void>;
+type BeforeProxyDisableHook$1 = (context: BeforeProxyDisableContext) => boolean | void | Promise<boolean | void>;
+type AfterProxyDisableHook$1 = (context: AfterProxyDisableContext) => void | Promise<void>;
+type AfterProxyRotateHook$1 = (context: AfterProxyRotateContext) => void | Promise<void>;
+type AfterProxyEnableHook$1 = (context: AfterProxyEnableContext) => void | Promise<void>;
+/**
+ * Proxy hooks collection for ProxyManager events
+ */
+export interface ProxyHooks {
+	beforeProxySelect: BeforeProxySelectHook$1[];
+	afterProxySelect: AfterProxySelectHook$1[];
+	beforeProxyError: BeforeProxyErrorHook$1[];
+	afterProxyError: AfterProxyErrorHook$1[];
+	beforeProxyDisable: BeforeProxyDisableHook$1[];
+	afterProxyDisable: AfterProxyDisableHook$1[];
+	afterProxyRotate: AfterProxyRotateHook$1[];
+	afterProxyEnable: AfterProxyEnableHook$1[];
+}
+declare class ProxyManager {
+	/** Configuration for the proxy manager */
+	readonly config: ProxyManagerConfig;
+	/** Internal proxy states map (proxyId -> state) */
+	private states;
+	/** Current index for sequential rotation */
+	private currentIndex;
+	/** Request counter for current proxy (sequential rotation) */
+	private currentProxyRequests;
+	/** Last selected proxy (for rotation tracking) */
+	private lastSelectedProxy;
+	/** Cooldown timers map (proxyId -> timerId) */
+	private cooldownTimers;
+	/** Total requests through manager */
+	private _totalRequests;
+	/** Total successful requests */
+	private _totalSuccesses;
+	/** Total failed requests */
+	private _totalFailures;
+	/** Proxy hooks */
+	hooks: ProxyHooks;
+	/**
+	 * Create a new ProxyManager instance
+	 * @param config - Proxy manager configuration
+	 */
+	constructor(config: ProxyManagerConfig);
+	/**
+	 * Create initial state for a proxy
+	 */
+	private createInitialState;
+	/**
+	 * Check if a URL should use proxy based on whitelist/blacklist
+	 * @param url - The request URL to check
+	 * @returns true if URL should use proxy, false if should go direct
+	 */
+	shouldProxy(url: string): boolean;
+	/**
+	 * Match a URL against a pattern
+	 */
+	private matchPattern;
+	/**
+	 * Get active proxies (not disabled)
+	 */
+	getActive(): ProxyInfo[];
+	/**
+	 * Get disabled proxies
+	 */
+	getDisabled(): ProxyInfo[];
+	/**
+	 * Get proxies in cooldown
+	 */
+	getCooldown(): ProxyInfo[];
+	/**
+	 * Process expired cooldowns and re-enable proxies
+	 */
+	private processExpiredCooldowns;
+	/**
+	 * Get next proxy based on rotation strategy
+	 * @param url - The request URL (for whitelist/blacklist checking)
+	 * @returns Selected proxy or null if should go direct
+	 */
+	next(url: string): ProxyInfo | null;
+	/**
+	 * Get detailed selection result with reason
+	 * @param url - The request URL
+	 * @returns Selection result with proxy and reason
+	 */
+	select(url: string): ProxySelectionResult;
+	/**
+	 * Select proxy based on rotation strategy
+	 */
+	private selectProxy;
+	/**
+	 * Report a successful request through a proxy
+	 * @param proxy - The proxy that succeeded
+	 */
+	reportSuccess(proxy: ProxyInfo): void;
+	/**
+	 * Report a failed request through a proxy
+	 * @param proxy - The proxy that failed
+	 * @param error - The error that occurred
+	 * @param url - Optional URL for hook context
+	 */
+	reportFailure(proxy: ProxyInfo, error: Error, url?: string): void;
+	/**
+	 * Disable a proxy from the pool
+	 * @param proxy - The proxy to disable
+	 * @param reason - Reason for disabling
+	 */
+	disableProxy(proxy: ProxyInfo, reason?: "dead" | "limit-reached" | "manual"): void;
+	/**
+	 * Enable a previously disabled proxy
+	 * @param proxy - The proxy to enable
+	 * @param reason - Reason for enabling
+	 */
+	enableProxy(proxy: ProxyInfo, reason?: "cooldown-expired" | "manual"): void;
+	/**
+	 * Add proxies to the pool
+	 * @param proxies - Proxies to add
+	 */
+	add(proxies: ProxyInfo | ProxyInfo[]): void;
+	/**
+	 * Remove proxies from the pool
+	 * @param proxies - Proxies to remove
+	 */
+	remove(proxies: ProxyInfo | ProxyInfo[]): void;
+	/**
+	 * Reset all proxies - re-enable all and reset counters
+	 */
+	reset(): void;
+	/**
+	 * Get current status of all proxies
+	 */
+	getStatus(): ProxyManagerStatus;
+	/**
+	 * Get state for a specific proxy
+	 * @param proxy - The proxy to get state for
+	 */
+	getProxyState(proxy: ProxyInfo): ProxyState | undefined;
+	/**
+	 * Check if any proxies are available
+	 */
+	hasAvailableProxies(): boolean;
+	/**
+	 * Destroy the manager and cleanup timers
+	 */
+	destroy(): void;
+	private runBeforeProxySelectHooksSync;
+	private runAfterProxySelectHooksSync;
+	private runBeforeProxyErrorHooksSync;
+	private runAfterProxyErrorHooksSync;
+	private runAfterProxyRotateHooks;
+	private runAfterProxyDisableHooks;
+	private runAfterProxyEnableHooks;
+}
 export type queueOptions = Options$1<PriorityQueue, QueueAddOptions>;
 export interface CacheConfig {
 	/** Response cache configuration */
@@ -2112,25 +2814,1052 @@ export interface RezoDefaultOptions {
 	 * DNS cache defaults: 1 min TTL, 1000 entries
 	 */
 	cache?: CacheOption;
+	/**
+	 * Proxy manager for advanced proxy rotation and pool management
+	 * - Provide a `ProxyManager` instance for full control
+	 * - Or provide `ProxyManagerConfig` to auto-create internally
+	 *
+	 * Note: ProxyManager overrides `proxy` option when set.
+	 * Use `useProxyManager: false` per-request to bypass.
+	 *
+	 * @example
+	 * ```typescript
+	 * // With config (auto-creates ProxyManager)
+	 * const client = new Rezo({
+	 *   proxyManager: {
+	 *     rotation: 'random',
+	 *     proxies: [
+	 *       { protocol: 'socks5', host: '127.0.0.1', port: 1080 },
+	 *       { protocol: 'http', host: 'proxy.example.com', port: 8080 }
+	 *     ],
+	 *     whitelist: ['api.example.com'],
+	 *     autoDisableDeadProxies: true
+	 *   }
+	 * });
+	 *
+	 * // With ProxyManager instance
+	 * const pm = new ProxyManager({ rotation: 'sequential', proxies: [...] });
+	 * const client = new Rezo({ proxyManager: pm });
+	 * ```
+	 */
+	proxyManager?: ProxyManager | ProxyManagerConfig;
+}
+export interface httpAdapterOverloads {
+	request<T = any>(options: RezoRequestOptions): Promise<RezoResponse<T>>;
+	request<T = any>(options: RezoRequestOptions & {
+		responseType: "auto";
+	}): Promise<RezoResponse<T>>;
+	request<T = any>(options: RezoRequestOptions & {
+		responseType: "json";
+	}): Promise<RezoResponse<T>>;
+	request(options: {
+		responseType: "stream";
+	} & RezoRequestOptions): Promise<RezoStreamResponse>;
+	request(options: RezoRequestOptions & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	request(options: RezoRequestOptions & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	request(options: RezoRequestOptions & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	request(options: RezoRequestOptions & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	request(options: RezoRequestOptions & {
+		responseType: "download";
+	}): Promise<RezoDownloadResponse>;
+	request(options: RezoRequestOptions & {
+		fileName: string;
+	}): Promise<RezoDownloadResponse>;
+	request(options: RezoRequestOptions & {
+		saveTo: string;
+	}): Promise<RezoDownloadResponse>;
+	request(options: RezoRequestOptions & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	get<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	get<T = any>(url: string | URL, options?: RezoHttpGetRequest): Promise<RezoResponse<T>>;
+	get<T = any>(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		responseType: "download";
+	}): Promise<RezoDownloadResponse>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		fileName: string;
+	}): Promise<RezoDownloadResponse>;
+	get(url: string | URL, options: RezoHttpGetRequest & {
+		saveTo: string;
+	}): Promise<RezoDownloadResponse>;
+	head(url: string | URL): Promise<RezoResponse<null>>;
+	head(url: string | URL, options: RezoHttpHeadRequest): Promise<RezoResponse<null>>;
+	options<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	options<T = any>(url: string | URL, options: RezoHttpOptionsRequest): Promise<RezoResponse<T>>;
+	trace<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	trace<T = any>(url: string | URL, options: RezoHttpRequest): Promise<RezoResponse<T>>;
+	delete<T = any>(url: string | URL, options?: RezoHttpDeleteRequest): Promise<RezoResponse<T>>;
+	delete<T = any>(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		responseType: "download";
+	}): Promise<RezoDownloadResponse>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		fileName: string;
+	}): Promise<RezoDownloadResponse>;
+	delete(url: string | URL, options: RezoHttpDeleteRequest & {
+		saveTo: string;
+	}): Promise<RezoDownloadResponse>;
 }
 /**
- * Execute HTTP/2 request - main adapter entry point
- * Follows the same pattern as http.ts executeRequest
+ * Extended URLSearchParams that supports nested objects and arrays
+ * for application/x-www-form-urlencoded encoding
  */
-declare function executeRequest<T = any>(options: RezoRequestConfig, defaultOptions: RezoDefaultOptions, jar: RezoCookieJar): Promise<RezoResponse<T> | RezoStreamResponse | RezoDownloadResponse | RezoUploadResponse>;
+export type Primitive = string | number | boolean | null | undefined | Date;
+export type NestedValue = Primitive | NestedObject | NestedArray;
+export type NestedObject = {
+	[key: string]: NestedValue;
+};
+export type NestedArray = NestedValue[];
+declare class RezoURLSearchParams extends URLSearchParams {
+	constructor(init?: string | URLSearchParams | NestedObject | string[][] | RezoURLSearchParams);
+	/**
+	 * Append a nested object to the search params
+	 */
+	appendObject(obj: NestedObject, prefix?: string): void;
+	/**
+	 * Set a value (replacing existing values with the same key)
+	 */
+	setObject(obj: NestedObject, prefix?: string): void;
+	/**
+	 * Append a value with proper handling for different types
+	 */
+	private appendValue;
+	/**
+	 * Append an array with proper indexing
+	 */
+	private appendArray;
+	/**
+	 * Convert to a plain object (useful for debugging)
+	 */
+	toObject(): Record<string, string>;
+	/**
+	 * Create from a flat object with bracket notation keys
+	 */
+	static fromFlat(flat: Record<string, string>): RezoURLSearchParams;
+}
+export interface httpAdapterPostOverloads {
+	post<T = any>(url: string | URL, data?: any): Promise<RezoResponse<T>>;
+	post<T = any>(url: string | URL, data: any, options?: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	post<T = any>(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "download";
+	}): Promise<RezoDownloadResponse>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		fileName: string;
+	}): Promise<RezoDownloadResponse>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		saveTo: string;
+	}): Promise<RezoDownloadResponse>;
+	post(url: string | URL, data: any, options: RezoHttpPostRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	postJson<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, jsonString: string): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, jsonString: string, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, jsonString: string, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	postJson<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	postJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postJson(url: string | URL, jsonString: string, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postJson(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postJson(url: string | URL, jsonString: string, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postJson(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postJson(url: string | URL, jsonString: string, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postJson(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postJson(url: string | URL, jsonString: string, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postJson(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postJson(url: string | URL, jsonString: string, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postJson(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postForm<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, string: string): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, string: string, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, string: string, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	postForm<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	postForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postForm(url: string | URL, string: string, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postForm(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postForm(url: string | URL, string: string, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postForm(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postForm(url: string | URL, string: string, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postForm(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postForm(url: string | URL, string: string, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postForm(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postForm(url: string | URL, string: string, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postForm(url: string | URL, nullData: null | undefined, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postMultipart<T = any>(url: string | URL, formData: RezoFormData): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: FormData): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, dataObject: Record<string, any>): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "auto";
+	}): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "auto";
+	}): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "auto";
+	}): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "json";
+	}): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "json";
+	}): Promise<RezoResponse<T>>;
+	postMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "json";
+	}): Promise<RezoResponse<T>>;
+	postMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postMultipart(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	postMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postMultipart(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "stream";
+	}): Promise<RezoStreamResponse>;
+	postMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postMultipart(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	postMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postMultipart(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	postMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postMultipart(url: string | URL, formData: FormData, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	postMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPostRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+}
+export interface httpAdapterPatchOverloads {
+	patch<T = any>(url: string | URL, data?: any): Promise<RezoResponse<T>>;
+	patch<T = any>(url: string | URL, data: any, options?: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patch<T = any>(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "download";
+	}): RezoDownloadResponse;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		fileName: string;
+	}): RezoDownloadResponse;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		saveTo: string;
+	}): RezoDownloadResponse;
+	patch(url: string | URL, data: any, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchJson<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, jsonString: string): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, jsonString: string, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchJson<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchJson(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchJson(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchJson(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchJson(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchJson(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchJson(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchJson(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchJson(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchJson(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchJson(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchJson(url: string | URL, jsonString: string, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchJson(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchForm<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, string: string): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, string: string, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchForm<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchForm(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchForm(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchForm(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchForm(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchForm(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchForm(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchForm(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchForm(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchForm(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchForm(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchForm(url: string | URL, string: string, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchForm(url: string | URL, nullData: null | undefined, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchMultipart<T = any>(url: string | URL, formData: RezoFormData): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, formData: FormData): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, dataObject: Record<string, any>): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	patchMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchMultipart(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	patchMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchMultipart(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	patchMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchMultipart(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	patchMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchMultipart(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	patchMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchMultipart(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	patchMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchMultipart(url: string | URL, formData: FormData, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	patchMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPatchRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+}
+export interface httpAdapterPutOverloads {
+	put<T = any>(url: string | URL, data?: any): Promise<RezoResponse<T>>;
+	put<T = any>(url: string | URL, data: any, options?: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	put<T = any>(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "download";
+	}): RezoDownloadResponse;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		fileName: string;
+	}): RezoDownloadResponse;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		saveTo: string;
+	}): RezoDownloadResponse;
+	put(url: string | URL, data: any, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putJson<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, jsonString: string): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, jsonString: string, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putJson<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putJson(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putJson(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putJson(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putJson(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putJson(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putJson(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putJson(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putJson(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putJson(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putJson(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putJson(url: string | URL, data: Record<any, any> | Array<any>, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putJson(url: string | URL, jsonString: string, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putJson(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putForm<T = any>(url: string | URL): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, string: string): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, string: string, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putForm<T = any>(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putForm(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putForm(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putForm(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putForm(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putForm(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putForm(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putForm(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putForm(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putForm(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putForm(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putForm(url: string | URL, data: URLSearchParams | RezoURLSearchParams | Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putForm(url: string | URL, string: string, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putForm(url: string | URL, nullData: null | undefined, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putMultipart<T = any>(url: string | URL, formData: RezoFormData): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, formData: FormData): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, dataObject: Record<string, any>): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putMultipart<T = any>(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "auto" | "json";
+	}): Promise<RezoResponse<T>>;
+	putMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putMultipart(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "text";
+	}): Promise<RezoResponse<string>>;
+	putMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putMultipart(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "stream";
+	}): RezoStreamResponse;
+	putMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putMultipart(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "arrayBuffer";
+	}): Promise<RezoResponse<ArrayBuffer>>;
+	putMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putMultipart(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "buffer";
+	}): Promise<RezoResponse<Buffer>>;
+	putMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putMultipart(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "blob";
+	}): Promise<RezoResponse<Blob$1>>;
+	putMultipart(url: string | URL, formData: RezoFormData, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putMultipart(url: string | URL, formData: FormData, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+	putMultipart(url: string | URL, dataObject: Record<string, any>, options: RezoHttpPutRequest & {
+		responseType: "upload";
+	}): Promise<RezoUploadResponse>;
+}
 /**
- * Execute HTTP request using Node.js http/https modules
+ * Adapter function type - all adapters must implement this signature
  */
-declare function executeRequest$1<T = any>(options: RezoRequestConfig, defaultOptions: RezoDefaultOptions, jar: RezoCookieJar): Promise<RezoResponse<T> | RezoStreamResponse | RezoDownloadResponse | RezoUploadResponse>;
+export type AdapterFunction<T = any> = (options: RezoRequestConfig, defaultOptions: RezoDefaultOptions, jar: RezoCookieJar) => Promise<RezoResponse<T> | RezoStreamResponse | RezoDownloadResponse | RezoUploadResponse>;
 /**
- * Unified adapter execution function type.
- * All adapters implement this signature for consistent behavior.
+ * Main Rezo class - Enterprise-grade HTTP client with advanced features
  */
-export type ExecuteRequestFn<T = any> = (options: RezoRequestConfig, defaultOptions: RezoDefaultOptions, jar: RezoCookieJar) => Promise<RezoResponse<T> | RezoStreamResponse | RezoDownloadResponse | RezoUploadResponse>;
+export declare class Rezo {
+	protected queue: PQueue | null;
+	protected isQueueEnabled: boolean;
+	defaults: RezoDefaultOptions;
+	hooks: RezoHooks;
+	private jar;
+	/** Session ID persists across all requests from this instance */
+	readonly sessionId: string;
+	/** Response cache for caching HTTP responses */
+	readonly responseCache?: ResponseCache;
+	/** DNS cache for caching DNS lookups */
+	readonly dnsCache?: DNSCache;
+	/** The adapter function used for HTTP requests */
+	private readonly adapter;
+	/** Proxy manager for advanced proxy rotation and pool management */
+	private readonly _proxyManager;
+	constructor(config?: RezoDefaultOptions, adapter?: AdapterFunction);
+	/**
+	 * Get the ProxyManager instance (if configured)
+	 * @returns ProxyManager instance or null
+	 */
+	get proxyManager(): ProxyManager | null;
+	/**
+	 * Clear all caches (response and DNS)
+	 */
+	clearCache(): void;
+	/**
+	 * Invalidate cached response for a specific URL
+	 */
+	invalidateCache(url: string, method?: string): void;
+	/**
+	 * Get cache statistics
+	 */
+	getCacheStats(): {
+		response?: {
+			size: number;
+			enabled: boolean;
+			persistent: boolean;
+		};
+		dns?: {
+			size: number;
+			enabled: boolean;
+		};
+	};
+	get: httpAdapterOverloads["get"];
+	head: httpAdapterOverloads["head"];
+	options: httpAdapterOverloads["options"];
+	trace: httpAdapterOverloads["trace"];
+	delete: httpAdapterOverloads["delete"];
+	request: httpAdapterOverloads["request"];
+	post: httpAdapterPostOverloads["post"];
+	postJson: httpAdapterPostOverloads["postJson"];
+	postForm: httpAdapterPostOverloads["postForm"];
+	postMultipart: httpAdapterPostOverloads["postMultipart"];
+	put: httpAdapterPutOverloads["put"];
+	putJson: httpAdapterPutOverloads["putJson"];
+	putForm: httpAdapterPutOverloads["putForm"];
+	putMultipart: httpAdapterPutOverloads["putMultipart"];
+	patch: httpAdapterPatchOverloads["patch"];
+	patchJson: httpAdapterPatchOverloads["patchJson"];
+	patchForm: httpAdapterPatchOverloads["patchForm"];
+	patchMultipart: httpAdapterPatchOverloads["patchMultipart"];
+	private executeRequest;
+	private buildFullUrl;
+	private isvalidJson;
+	private __create;
+	/** Get the cookie jar for this instance */
+	get cookieJar(): RezoCookieJar;
+	/**
+	 * Save cookies to file (if cookieFile is configured).
+	 * Can also specify a different path to save to.
+	 */
+	saveCookies(filePath?: string): void;
+	/**
+	 * Stream a resource - returns immediately with StreamResponse
+	 * The response data is emitted via 'data' events.
+	 *
+	 * @param url - URL to stream from
+	 * @param options - Request options (optional)
+	 * @returns StreamResponse that emits 'data', 'end', 'error' events
+	 *
+	 * @example
+	 * ```typescript
+	 * const stream = rezo.stream('https://example.com/large-file');
+	 * stream.on('data', (chunk) => console.log('Received:', chunk.length, 'bytes'));
+	 * stream.on('end', () => console.log('Stream complete'));
+	 * stream.on('error', (err) => console.error('Error:', err));
+	 * ```
+	 */
+	stream(url: string | URL, options?: RezoHttpRequest): RezoStreamResponse;
+	/**
+	 * Download a resource to a file - returns immediately with DownloadResponse
+	 * The download progress and completion are emitted via events.
+	 *
+	 * @param url - URL to download from
+	 * @param saveTo - File path to save the download to
+	 * @param options - Request options (optional)
+	 * @returns DownloadResponse that emits 'progress', 'complete', 'error' events
+	 *
+	 * @example
+	 * ```typescript
+	 * const download = rezo.download('https://example.com/file.zip', './downloads/file.zip');
+	 * download.on('progress', (p) => console.log(`${p.percent}% complete`));
+	 * download.on('complete', () => console.log('Download finished'));
+	 * download.on('error', (err) => console.error('Error:', err));
+	 * ```
+	 */
+	download(url: string | URL, saveTo: string, options?: RezoHttpRequest): RezoDownloadResponse;
+	/**
+	 * Upload data with progress tracking - returns immediately with UploadResponse
+	 * The upload progress and completion are emitted via events.
+	 *
+	 * @param url - URL to upload to
+	 * @param data - Data to upload (Buffer, FormData, string, etc.)
+	 * @param options - Request options (optional)
+	 * @returns UploadResponse that emits 'progress', 'complete', 'error' events
+	 *
+	 * @example
+	 * ```typescript
+	 * const upload = rezo.upload('https://example.com/upload', fileBuffer);
+	 * upload.on('progress', (p) => console.log(`${p.percent}% uploaded`));
+	 * upload.on('complete', (response) => console.log('Upload finished:', response));
+	 * upload.on('error', (err) => console.error('Error:', err));
+	 * ```
+	 */
+	upload(url: string | URL, data: Buffer | FormData | RezoFormData | string | Record<string, any>, options?: RezoHttpRequest): RezoUploadResponse;
+}
+/**
+ * Extended Rezo instance with Axios-compatible static helpers.
+ * Provides drop-in replacement API surface for Axios users.
+ */
+export interface RezoInstance extends Rezo {
+	/** Create a new Rezo instance with custom configuration */
+	create(config?: RezoDefaultOptions): Rezo;
+	/** Type guard to check if an error is a RezoError instance */
+	isRezoError: typeof RezoError.isRezoError;
+	/** Check if an error is a cancellation error */
+	isCancel: (error: unknown) => boolean;
+	/** Alias for RezoError (Axios compatibility) */
+	Cancel: typeof RezoError;
+	/** AbortController for request cancellation (Axios compatibility) */
+	CancelToken: typeof AbortController;
+	/** Promise.all wrapper (Axios compatibility) */
+	all: typeof Promise.all;
+	/** Spread array arguments to callback function (Axios compatibility) */
+	spread: <T extends unknown[], R>(callback: (...args: T) => R) => (array: T) => R;
+}
+export declare const isRezoError: typeof RezoError.isRezoError;
+export declare const Cancel: typeof RezoError;
+export declare const CancelToken: {
+	new (): AbortController;
+	prototype: AbortController;
+};
+export declare const isCancel: (error: unknown) => boolean;
+export declare const all: {
+	<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
+	<T extends readonly unknown[] | [
+	]>(values: T): Promise<{
+		-readonly [P in keyof T]: Awaited<T[P]>;
+	}>;
+};
+export declare const spread: <T extends unknown[], R>(callback: (...args: T) => R) => (array: T) => R;
+export declare const VERSION: string;
+declare const rezo: RezoInstance;
 
 export {
-	executeRequest as executeHttp2Request,
-	executeRequest$1 as executeHttpRequest,
+	ResponseType$1 as ResponseType,
+	rezo as default,
 };
 
 export {};