@bereasoftware/nexa 1.2.0 → 1.4.0

package/dist/types/dev-overlay/index.d.ts

@@ -0,0 +1,15 @@
+export { RequestTracker } from './tracker';
+export { DevOverlayUI } from './overlay';
+export type { TrackedRequest, DevMetrics, DevOverlayConfig } from './types';
+import { RequestTracker } from './tracker';
+import { DevOverlayUI } from './overlay';
+import type { DevOverlayConfig } from './types';
+export declare function createDevOverlay(config?: DevOverlayConfig): {
+    tracker: RequestTracker;
+    ui: DevOverlayUI;
+};
+export declare function getDevOverlay(): {
+    tracker: RequestTracker | null;
+    ui: DevOverlayUI | null;
+};
+export declare function destroyDevOverlay(): void;

package/dist/types/dev-overlay/overlay.d.ts

@@ -0,0 +1,30 @@
+import type { RequestTracker } from './tracker';
+export declare class DevOverlayUI {
+    private panel;
+    private tracker;
+    private visible;
+    private selectedRequest;
+    private config;
+    private searchQuery;
+    private removeTrackerListener;
+    private keyboardShortcutHandler;
+    private globalKeyboardHandler;
+    constructor(tracker: RequestTracker);
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    destroy(): void;
+    private setupKeyboardShortcut;
+    private createPanel;
+    private bindEvents;
+    private render;
+    private renderMetricsBar;
+    private renderRequestList;
+    private renderMetrics;
+    private showDetail;
+    private showMainView;
+    private retrySelected;
+    private truncateUrl;
+    private formatJson;
+    private canUseDOM;
+}

package/dist/types/dev-overlay/tracker.d.ts

@@ -0,0 +1,16 @@
+import type { TrackedRequest, DevMetrics, DevOverlayConfig } from './types';
+export declare class RequestTracker {
+    private history;
+    private maxHistory;
+    private listeners;
+    private startTime;
+    private config;
+    constructor(config?: DevOverlayConfig);
+    track(request: Omit<TrackedRequest, 'id' | 'timestamp'>): TrackedRequest;
+    getHistory(): TrackedRequest[];
+    getMetrics(): DevMetrics;
+    clear(): void;
+    onChange(listener: (request: TrackedRequest) => void): () => void;
+    getConfig(): Required<DevOverlayConfig>;
+    private generateId;
+}

package/dist/types/dev-overlay/types.d.ts

@@ -0,0 +1,33 @@
+export interface TrackedRequest {
+    id: string;
+    method: string;
+    url: string;
+    status?: number;
+    duration: number;
+    timestamp: number;
+    cached: boolean;
+    ok: boolean;
+    code?: string;
+    headers: Record<string, string>;
+    body?: unknown;
+    responseHeaders?: Record<string, string>;
+    retryCount: number;
+}
+export interface DevMetrics {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    cachedRequests: number;
+    avgDuration: number;
+    maxDuration: number;
+    minDuration: number;
+    requestsPerSecond: number;
+    slowestRequests: TrackedRequest[];
+}
+export interface DevOverlayConfig {
+    enabled?: boolean;
+    maxHistory?: number;
+    keyboardShortcut?: string;
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+    theme?: 'dark' | 'light';
+}

package/dist/types/http-client/http-client.d.ts

@@ -1,4 +1,35 @@
-import { IHttpClient, HttpRequestConfig, HttpResponse, HttpErrorDetails, RequestInterceptor, ResponseInterceptor, HttpClientConfig, PaginateOptions, PollOptions, Disposer, Result } from '../types';
+/**
+ * HTTP Client Implementation
+ * Superior to fetch + axios:
+ *
+ * vs fetch:
+ *   ✓ Automatic JSON parsing + error handling via Result<T,E>
+ *   ✓ Interceptors, retry, cache, timeout built-in
+ *   ✓ Progress tracking for uploads/downloads
+ *   ✓ Path parameter interpolation (/users/:id)
+ *   ✓ Request lifecycle hooks (onStart, onSuccess, onError, onFinally, onRetry)
+ *   ✓ Auto content-type detection (FormData, Blob, URLSearchParams, etc.)
+ *   ✓ Concurrent request limiting (rate limiter)
+ *
+ * vs axios:
+ *   ✓ Zero dependencies (~3KB gzipped vs axios ~13KB)
+ *   ✓ Result<T,E> monad — no try/catch needed, type-safe error handling
+ *   ✓ Built-in request deduplication
+ *   ✓ Streaming support with chunk callbacks
+ *   ✓ Plugin architecture (SOLID)
+ *   ✓ Middleware pipeline (Express/Koa-like)
+ *   ✓ Circuit breaker retry strategy
+ *   ✓ Response duration tracking
+ *   ✓ Modern ESM-first with tree-shaking
+ *
+ * SOLID Principles:
+ * - S: HttpClient → HTTP communication
+ * - O: Extensible via interceptors, strategies, plugins
+ * - L: Liskov — implementations interchange without breaking
+ * - I: Interface Segregation — small focused interfaces
+ * - D: Dependency Inversion — depends on abstractions (IHttpClient)
+ */
+import type { IHttpClient, HttpRequestConfig, HttpResponse, HttpErrorDetails, RequestInterceptor, ResponseInterceptor, HttpClientConfig, PaginateOptions, PollOptions, Disposer, Result } from '../types';
 /**
  * Main HTTP Client Implementation
  * Combines fetch API with axios-like convenience + modern features
@@ -7,23 +38,29 @@ export declare class HttpClient implements IHttpClient {
     private requestInterceptors;
     private responseInterceptors;
     private cache;
+    private devTracker;
     private config;
     private requestQueue;
     private pendingRequests;
     constructor(config?: HttpClientConfig);
-    private logDebug;
     /**
      * Core request method — all others delegate to this
-     * Pipeline: hooks → cache → interceptors → transformRequest → fetch → parse → validate → transformResponse → interceptors → cache → hooks
+     * Pipeline: hooks → cache → interceptors → fetch → parse → validate → transform → interceptors → cache → hooks
+     * Fast path: when no features are used, goes directly to fetch
      */
     request<T = unknown>(config: HttpRequestConfig): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
-    get<T = unknown>(url: string, config?: Omit<HttpRequestConfig, "url" | "method">): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
-    post<T = unknown>(url: string, body?: unknown, config?: Omit<HttpRequestConfig, "url" | "method" | "body">): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
-    put<T = unknown>(url: string, body?: unknown, config?: Omit<HttpRequestConfig, "url" | "method" | "body">): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
-    patch<T = unknown>(url: string, body?: unknown, config?: Omit<HttpRequestConfig, "url" | "method" | "body">): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
-    delete<T = unknown>(url: string, config?: Omit<HttpRequestConfig, "url" | "method">): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
-    head(url: string, config?: Omit<HttpRequestConfig, "url" | "method">): Promise<Result<HttpResponse<void>, HttpErrorDetails>>;
-    options(url: string, config?: Omit<HttpRequestConfig, "url" | "method">): Promise<Result<HttpResponse<void>, HttpErrorDetails>>;
+    /**
+     * Fast path — minimal overhead for simple requests without features
+     * No interceptors, cache, hooks, retry, validate, transform, queue, progress, or signal
+     */
+    private fastPath;
+    get<T = unknown>(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
+    post<T = unknown>(url: string, body?: unknown, config?: Omit<HttpRequestConfig, 'url' | 'method' | 'body'>): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
+    put<T = unknown>(url: string, body?: unknown, config?: Omit<HttpRequestConfig, 'url' | 'method' | 'body'>): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
+    patch<T = unknown>(url: string, body?: unknown, config?: Omit<HttpRequestConfig, 'url' | 'method' | 'body'>): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
+    delete<T = unknown>(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
+    head(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<Result<HttpResponse<void>, HttpErrorDetails>>;
+    options(url: string, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<Result<HttpResponse<void>, HttpErrorDetails>>;
     addRequestInterceptor(interceptor: RequestInterceptor): Disposer;
     addResponseInterceptor(interceptor: ResponseInterceptor): Disposer;
     clearInterceptors(): void;
@@ -65,7 +102,7 @@ export declare class HttpClient implements IHttpClient {
      * }
      * ```
      */
-    paginate<T = unknown>(url: string, options: PaginateOptions<T>, config?: Omit<HttpRequestConfig, "url" | "method">): AsyncGenerator<T[]>;
+    paginate<T = unknown>(url: string, options: PaginateOptions<T>, config?: Omit<HttpRequestConfig, 'url' | 'method'>): AsyncGenerator<T[]>;
     /**
      * Poll an endpoint until a condition is met.
      * Returns the final response that satisfied `until()`.
@@ -80,33 +117,24 @@ export declare class HttpClient implements IHttpClient {
      * });
      * ```
      */
-    poll<T = unknown>(url: string, options: PollOptions<T>, config?: Omit<HttpRequestConfig, "url" | "method">): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
+    poll<T = unknown>(url: string, options: PollOptions<T>, config?: Omit<HttpRequestConfig, 'url' | 'method'>): Promise<Result<HttpResponse<T>, HttpErrorDetails>>;
     private buildRequest;
     private buildUrl;
-    /**
-     * Apply transformRequest functions to the request body and headers.
-     * Combines global transformRequest (from client config) and request-specific transformRequest.
-     * Mutates headers object in place (axios-style).
-     */
-    private applyTransformRequestToRequest;
     private getCacheKey;
     private fetchWithTimeout;
     /**
      * Wraps response body with a progress-tracking ReadableStream
      */
     private trackDownloadProgress;
-    /**
-     * Wraps a promise with a timeout. If the timeout elapses before the promise resolves,
-     * rejects with a TimeoutError.
-     */
-    private withTimeout;
     private parseResponse;
     private parseBody;
     private normalizeError;
     private isHttpErrorDetails;
     private getMaxAttempts;
     private getRetryStrategy;
+    private resolveTimeoutMs;
     private delay;
+    private trackDev;
 }
 export declare class HttpError extends Error {
     status: number;

package/dist/types/http-client/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * HTTP Client Plugin - Main Exports
  */
-export { createHttpClient, HttpClient, HttpError, isHttpError } from './http-client.js';
+export { createHttpClient, HttpClient, HttpError, isHttpError, } from './http-client.js';
 export type { IHttpClient, HttpRequest, HttpRequestConfig, HttpResponse, HttpErrorDetails, RequestInterceptor, ResponseInterceptor, RetryStrategy, CacheStrategy, Validator, Transformer, HttpClientConfig, ResponseType, RequestHooks, ProgressEvent, PaginateOptions, PollOptions, Disposer, Result, } from '../types/index.js';
 export { Ok, Err } from '../types/index.js';
-export { withTimeout, retry, createSchemaValidator, createRequiredFieldsValidator, validatorIsArray, validatorIsObject, transformSnakeToCamel, transformCamelToSnake, transformFlatten, createProjectionTransformer, createWrapperTransformer, AggressiveRetry, ConservativeRetry, CircuitBreakerRetry, CacheStore, createCacheMiddleware, cacheMiddleware, RequestDeduplicator, createDedupeMiddleware, dedupeMiddleware, createRateLimitMiddleware, rateLimitMiddleware, createCircuitBreakerMiddleware, circuitBreakerMiddleware, MiddlewarePipeline, createPipeline, type Middleware, type HttpContext, createTypedResponse, createTypedRequest, createTypedApiClient, createTypeGuard, createUrl, createApiUrl, TypedObservable, Defer, type TypedResponse, type ApiEndpoint, type ApiSchema, type Url, type ApiUrl, type FileUrl, type UnionToIntersection, type ResultOf, handleStream, streamToFile, createStreamingMiddleware, streamingMiddleware, type StreamOptions, PluginManager, LoggerPlugin, MetricsPlugin, CachePlugin, DedupePlugin, RateLimitPlugin, CircuitBreakerPlugin, type Plugin, } from '../utils';
+export { withTimeout, retry, createSchemaValidator, createRequiredFieldsValidator, validatorIsArray, validatorIsObject, transformSnakeToCamel, transformCamelToSnake, transformFlatten, createProjectionTransformer, createWrapperTransformer, AggressiveRetry, ConservativeRetry, CircuitBreakerRetry, CacheStore, createCacheMiddleware, cacheMiddleware, RequestDeduplicator, createDedupeMiddleware, dedupeMiddleware, MiddlewarePipeline, createPipeline, type Middleware, type HttpContext, createTypedResponse, createTypedRequest, createTypedApiClient, createTypeGuard, createUrl, createApiUrl, TypedObservable, Defer, type TypedResponse, type ApiEndpoint, type ApiSchema, type Url, type ApiUrl, type FileUrl, type UnionToIntersection, type ResultOf, handleStream, streamToFile, createStreamingMiddleware, streamingMiddleware, type StreamOptions, PluginManager, LoggerPlugin, MetricsPlugin, CachePlugin, DedupePlugin, type Plugin, } from '../utils';

package/dist/types/http-client/node-http-adapter.d.ts

@@ -1,4 +1,9 @@
-import { NodeTransportOptions } from '../types/index.js';
+/**
+ * Node.js HTTP/1.1 adapter using native http/https modules.
+ * Supports keep-alive, connection pooling, and other Node-specific options.
+ */
+import type { NodeTransportOptions } from '../types/index.js';
+import type * as Http2Module from 'http2';
 declare class Http2SessionPool {
     private sessions;
     private cleanupInterval;
@@ -8,7 +13,7 @@ declare class Http2SessionPool {
     private startCleanup;
     private cleanup;
     private closeSession;
-    getSession(origin: string, options?: NodeTransportOptions): Promise<import('http2').ClientHttp2Session>;
+    getSession(origin: string, options?: NodeTransportOptions): Promise<Http2Module.ClientHttp2Session>;
     releaseSession(origin: string): void;
     getStats(): {
         sessionCount: number;

package/dist/types/index.d.ts

@@ -3,6 +3,9 @@
  * Combines fetch power + axios convenience with SOLID principles
  */
 export * from './http-client';
-export * from './realtime/index.js';
-export { createMockClient, MockAdapter } from './testing/index.js';
-export type { MockResponse, MockClientOptions } from './testing/index.js';
+export * from './realtime';
+export * from './types';
+export * from './utils';
+export { createDevOverlay, getDevOverlay, destroyDevOverlay, } from './dev-overlay';
+export type { TrackedRequest, DevMetrics, DevOverlayConfig, } from './dev-overlay';
+export { RequestTracker } from './dev-overlay';

package/dist/types/realtime/plugin.d.ts

@@ -1,4 +1,8 @@
-import { Plugin, PluginManager } from '../utils/index.js';
+/**
+ * Real-time plugin for Nexa
+ * Provides WebSocket and SSE integration with the plugin system
+ */
+import type { Plugin, PluginManager } from '../utils/index.js';
 /**
  * Real-time plugin that adds WebSocket and SSE event listeners to the plugin manager
  */

package/dist/types/realtime/sse-client.d.ts

@@ -1,4 +1,7 @@
-import { SSEOptions, ISSEClient } from '../types/index.js';
+/**
+ * Server-Sent Events (SSE) client with automatic reconnection and plugin support.
+ */
+import type { SSEOptions, ISSEClient } from '../types/index.js';
 /**
  * Create an SSE client appropriate for the current environment
  */

package/dist/types/realtime/websocket-client.d.ts

@@ -1,4 +1,7 @@
-import { WebSocketOptions, IWebSocketClient } from '../types/index.js';
+/**
+ * WebSocket client with automatic reconnection, heartbeat, and plugin support.
+ */
+import type { WebSocketOptions, IWebSocketClient } from '../types/index.js';
 /**
  * Create a WebSocket client appropriate for the current environment
  */

package/dist/types/types/index.d.ts

@@ -30,11 +30,11 @@ export interface HttpRequest {
      */
     credentials?: RequestCredentials;
     /**
-     * Adapter personalizado para esta request (firma igual a fetch).
+     * Custom adapter for this request (same signature as fetch).
      */
     adapter?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
     /**
-     * Si es true (default), convierte automáticamente el body a FormData si detecta archivos.
+     * If true (default), automatically converts body to FormData if files are detected.
      */
     autoFormData?: boolean;
     /**
@@ -174,31 +174,9 @@ export type HttpTimeout = number | {
      */
     total?: number;
 };
-/**
- * Configuración extendida para solicitudes HTTP.
- * - credentials: controla el envío de cookies/credenciales ('omit' | 'same-origin' | 'include').
- */
 export interface HttpRequestConfig extends HttpRequest {
-    /**
-     * Si es true (default), convierte automáticamente el body a FormData si detecta archivos.
-     */
-    autoFormData?: boolean;
-    /**
-     * Compatibilidad con axios: si es true, establece credentials: 'include'; si es false, credentials: 'same-origin'.
-     * Si también se especifica credentials, este campo es ignorado.
-     */
-    withCredentials?: boolean;
-    /**
-     * Permite usar un adapter personalizado para la request (firma igual a fetch).
-     * Útil para mocks, tests, o entornos especiales.
-     */
-    adapter?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
-    /**
-     * Permite transformar el body antes de serializarlo y enviarlo. Similar a axios.transformRequest.
-     * Puede ser una función o un array de funciones.
-     */
-    transformRequest?: ((data: unknown, headers: Record<string, string>) => unknown) | Array<(data: unknown, headers: Record<string, string>) => unknown>;
     retry?: RetryStrategy | InlineRetryConfig;
+    timeout?: HttpTimeout;
     validate?: Validator;
     transform?: Transformer;
     cache?: {
@@ -209,6 +187,21 @@ export interface HttpRequestConfig extends HttpRequest {
     hooks?: RequestHooks;
     onUploadProgress?: (event: ProgressEvent) => void;
     onDownloadProgress?: (event: ProgressEvent) => void;
+    /**
+     * Axios compatibility: if true, sets credentials: 'include'; if false, credentials: 'same-origin'.
+     * If credentials is also specified, this field is ignored.
+     */
+    withCredentials?: boolean;
+    /**
+     * Allows using a custom adapter for the request (same signature as fetch).
+     * Useful for mocks, tests, or special environments.
+     */
+    adapter?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+    /**
+     * Allows transforming the body before serializing and sending it. Similar to axios.transformRequest.
+     * Can be a function or an array of functions.
+     */
+    transformRequest?: ((data: unknown, headers: Record<string, string>) => unknown) | Array<(data: unknown, headers: Record<string, string>) => unknown>;
     /**
      * Enable debug logging for this request. Overrides global debug setting.
      */
@@ -227,6 +220,10 @@ export interface HttpRequestConfig extends HttpRequest {
      * Overrides global nodeOptions.
      */
     nodeOptions?: NodeTransportOptions;
+    /**
+     * If true (default), automatically converts body to FormData if files are detected.
+     */
+    autoFormData?: boolean;
 }
 export interface PaginateOptions<T> {
     /** Extract items from a response page */
@@ -265,34 +262,35 @@ export interface IHttpClient {
 /** Function that removes a previously added interceptor */
 export type Disposer = () => void;
 export interface HttpClientConfig {
+    baseURL?: string;
+    defaultHeaders?: Record<string, string>;
+    defaultTimeout?: HttpTimeout;
+    cacheStrategy?: CacheStrategy;
+    validateStatus?: (status: number) => boolean;
+    maxConcurrent?: number;
+    defaultResponseType?: ResponseType;
+    defaultHooks?: RequestHooks;
+    devTracker?: DevTracker;
     /**
-     * Adapter global para todas las requests (firma igual a fetch).
+     * Global adapter for all requests (same signature as fetch).
      */
     adapter?: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
-    baseURL?: string;
-    defaultHeaders?: Record<string, string>;
     /**
      * Controls cookie/credential policy for CORS requests. Same as fetch API.
      * 'omit' | 'same-origin' | 'include'
      */
     credentials?: RequestCredentials;
     /**
-     * Compatibilidad con axios: si es true, establece credentials: 'include'; si es false, credentials: 'same-origin'.
-     * Si también se especifica credentials, este campo es ignorado.
+     * Axios compatibility: if true, sets credentials: 'include'; if false, credentials: 'same-origin'.
+     * If credentials is also specified, this field is ignored.
      */
     withCredentials?: boolean;
-    defaultTimeout?: HttpTimeout;
-    cacheStrategy?: CacheStrategy;
-    validateStatus?: (status: number) => boolean;
-    maxConcurrent?: number;
-    defaultResponseType?: ResponseType;
-    defaultHooks?: RequestHooks;
     /**
-     * Permite transformar el body antes de serializarlo y enviarlo por defecto en todas las requests.
+     * Allows transforming the body before serializing and sending it by default in all requests.
      */
     transformRequest?: ((data: unknown, headers: Record<string, string>) => unknown) | Array<(data: unknown, headers: Record<string, string>) => unknown>;
     /**
-     * Si es true (default), convierte automáticamente el body a FormData si detecta archivos.
+     * If true (default), automatically converts body to FormData if files are detected.
      */
     autoFormData?: boolean;
     /**
@@ -311,12 +309,6 @@ export interface HttpClientConfig {
      * - 'deno': Uses Deno's fetch API (Deno environment)
      * - 'bun': Uses Bun's fetch API (Bun environment)
      * - 'cloudflare': Uses Cloudflare Workers fetch API
-     *
-     * When 'node' or 'http2' is specified, nodeOptions can be used to configure
-     * keep-alive, connection pooling, and other Node-specific settings.
-     *
-     * Note: Node transports are only available in Node.js environments.
-     * Deno, Bun, and Cloudflare transports use their respective fetch implementations.
      */
     transport?: 'fetch' | 'node' | 'http2' | 'deno' | 'bun' | 'cloudflare';
     /**
@@ -325,6 +317,20 @@ export interface HttpClientConfig {
      */
     nodeOptions?: NodeTransportOptions;
 }
+export interface DevTracker {
+    track(request: {
+        method: string;
+        url: string;
+        status?: number;
+        duration: number;
+        cached: boolean;
+        ok: boolean;
+        code?: string;
+        headers: Record<string, string>;
+        body?: unknown;
+        retryCount: number;
+    }): void;
+}
 /**
  * WebSocket connection options
  */

package/dist/types/utils/index.d.ts

@@ -1,4 +1,8 @@
-import { Validator, Transformer, RetryStrategy, HttpErrorDetails, IHttpClient } from '../types';
+/**
+ * HTTP Client Utilities
+ * Common validators, transformers, and helpers
+ */
+import type { Validator, Transformer, RetryStrategy, HttpErrorDetails, IHttpClient } from '../types';
 /**
  * Schema validator using simple checks (can be replaced with Zod, Yup, etc)
  */
@@ -129,43 +133,6 @@ export declare function createDedupeMiddleware(options?: {
  * Pre-configured deduplication middleware for GET requests
  */
 export declare const dedupeMiddleware: Middleware<HttpContext>;
-/**
- * Rate limiting middleware factory - limits requests per time window
- */
-export declare function createRateLimitMiddleware(options?: {
-    /** Maximum number of requests per window */
-    maxRequests: number;
-    /** Time window in milliseconds (default: 60000 = 1 minute) */
-    windowMs?: number;
-    /** Function to generate rate limit key (default: uses request URL) */
-    keyGenerator?: (ctx: HttpContext) => string;
-    /** Custom error response when limit is exceeded (default: 429 Too Many Requests) */
-    errorResponse?: {
-        status: number;
-        body: unknown;
-    };
-}): Middleware<HttpContext>;
-/**
- * Pre-configured rate limit middleware: 100 requests per minute per endpoint
- */
-export declare const rateLimitMiddleware: Middleware<HttpContext>;
-/**
- * Circuit breaker middleware factory - prevents cascading failures
- */
-export declare function createCircuitBreakerMiddleware(options?: {
-    /** Failure threshold to open circuit (default: 5) */
-    failureThreshold?: number;
-    /** Time in ms to wait before attempting again (default: 30000) */
-    resetTimeout?: number;
-    /** Function to determine if a response is a failure (default: status >= 500) */
-    isFailure?: (ctx: HttpContext) => boolean;
-    /** Function to generate circuit key (default: uses request URL) */
-    keyGenerator?: (ctx: HttpContext) => string;
-}): Middleware<HttpContext>;
-/**
- * Pre-configured circuit breaker middleware
- */
-export declare const circuitBreakerMiddleware: Middleware<HttpContext>;
 /**
  * HTTP Context passed through middleware chain
  */
@@ -239,7 +206,7 @@ export type ApiSchema = Record<string, ApiEndpoint>;
  * Create a typed API client from schema
  */
 export declare function createTypedApiClient<T extends ApiSchema>(schema: T): {
-    request: <K extends keyof T>(client: IHttpClient, endpoint: K, data?: T[K] extends ApiEndpoint<infer TReq, any> ? TReq : never) => Promise<T[K] extends ApiEndpoint<any, infer TRes> ? TRes : never>;
+    request: <K extends keyof T>(client: IHttpClient, endpoint: K, data?: T[K] extends ApiEndpoint<infer TReq, unknown> ? TReq : never) => Promise<T[K] extends ApiEndpoint<unknown, infer TRes> ? TRes : never>;
 };
 /**
  * Observable-like response wrapper for reactive patterns
@@ -260,7 +227,7 @@ export declare class TypedObservable<T> {
 /**
  * Union type helper - extracts success/error types
  */
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /**
  * Result type extractor for discriminated unions
  */
@@ -426,35 +393,4 @@ export declare class DedupePlugin implements Plugin {
     name: string;
     setup(manager: PluginManager): void;
 }
-/**
- * Rate limiting plugin - adds rate limiting middleware
- */
-export declare class RateLimitPlugin implements Plugin {
-    name: string;
-    private options;
-    constructor(options?: {
-        maxRequests?: number;
-        windowMs?: number;
-        keyGenerator?: (ctx: HttpContext) => string;
-        errorResponse?: {
-            status: number;
-            body: unknown;
-        };
-    });
-    setup(manager: PluginManager): void;
-}
-/**
- * Circuit breaker plugin - adds circuit breaker middleware
- */
-export declare class CircuitBreakerPlugin implements Plugin {
-    name: string;
-    private options;
-    constructor(options?: {
-        failureThreshold?: number;
-        resetTimeout?: number;
-        isFailure?: (ctx: HttpContext) => boolean;
-        keyGenerator?: (ctx: HttpContext) => string;
-    });
-    setup(manager: PluginManager): void;
-}
 export type { HttpErrorDetails };