hyperwiz/dist/index.d.ts

Next-generation TypeScript HTTP client with built-in retry, smart caching, and seamless authentication. Effortlessly handle API requests with advanced features for modern web development.

interface RequestConfig {
    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'PURGE';
    headers?: HeadersInit;
    body?: unknown;
    signal?: AbortSignal;
}
interface RetryConfig {
    maxRetries?: number;
    retryDelay?: number;
    maxDelay?: number;
    backoffMultiplier?: number;
    retryOnStatus?: number[];
    retryOnNetworkError?: boolean;
}
type RetryConfigOption = boolean | RetryConfig;
interface CacheConfig {
    enabled?: boolean;
    maxAge?: number;
    maxSize?: number;
    storage?: 'memory' | 'indexeddb';
    includeQueryParams?: boolean;
    cacheableMethods?: string[];
    cacheableStatusCodes?: number[];
}
type CacheConfigOption = boolean | CacheConfig;
interface CacheStorage {
    get(key: string): Promise<CachedResponse | null>;
    set(key: string, value: CachedResponse): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
    keys(): Promise<string[]>;
}
interface CachedResponse {
    data: unknown;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    timestamp: number;
    url: string;
    method: string;
}
interface CacheKeyGenerator {
    generate(method: string, url: string, body?: unknown): string;
}
type RequestHandler = (config: RequestConfig, url: string) => RequestConfig | Promise<RequestConfig>;
type ResponseHandler<T = unknown> = (response: Response, data: T, url: string) => T | Promise<T>;
type ErrorHandler = (error: unknown, url: string, requestConfig?: RequestConfig) => unknown | Promise<unknown>;
interface Interceptors {
    before?: RequestHandler[];
    after?: ResponseHandler[];
    onError?: ErrorHandler[];
}
type RequestInterceptor = RequestHandler;
type ResponseInterceptor<T = unknown> = ResponseHandler<T>;
type ErrorInterceptor = ErrorHandler;

type ApiResponse$1<T> = {
    success: true;
    data: T;
} | {
    success: false;
    status?: number;
    error: string;
};
declare class HttpClient {
    private baseUrl;
    private interceptors;
    private timeoutControllers;
    private credentials;
    private timeoutHandler?;
    enableLogging?: boolean;
    constructor(baseUrl: string, interceptors?: Interceptors, credentials?: RequestCredentials);
    setCredentials(credentials: RequestCredentials): void;
    private runBeforeHandlers;
    private runAfterHandlers;
    private runErrorHandlers;
    private request;
    get<T>(url: string, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    post<T>(url: string, body: unknown, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    put<T>(url: string, body: unknown, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    patch<T>(url: string, body: unknown, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    delete<T>(url: string, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    head<T>(url: string, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    options<T>(url: string, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    purge<T>(url: string, headers?: HeadersInit): Promise<ApiResponse$1<T>>;
    fetch<T>(url: string, options?: RequestInit): Promise<ApiResponse$1<T>>;
    addBefore(handler: RequestHandler): void;
    addAfter(handler: ResponseHandler): void;
    addErrorHandler(handler: ErrorHandler): void;
    removeBefore(handler: RequestHandler): void;
    removeAfter(handler: ResponseHandler): void;
    removeErrorHandler(handler: ErrorHandler): void;
    clearInterceptors(): void;
    cancelAllRequests(): void;
    setTimeout(timeoutMs: number): void;
}

interface ClientConfig {
    interceptors?: Interceptors;
    logging?: boolean;
    timeout?: number;
    credentials?: RequestCredentials;
    retry?: RetryConfigOption;
    cache?: CacheConfigOption;
}
declare const createClient: (baseUrl: string, config?: ClientConfig) => HttpClient;
declare const createPublicClient: (baseUrl: string) => HttpClient;
declare const cleanupCircuitBreakers: () => void;
declare const cleanupRetryAttempts: () => void;
declare const cleanupPendingRequests: () => void;
declare const getMemoryStats: () => {
    circuitBreakers: number;
    retryAttempts: number;
    pendingRequests: number;
    globalCacheStorages: number;
};

type ApiResponse<T> = {
    success: true;
    data: T;
} | {
    success: false;
    status?: number;
    error: string;
};

export { type ApiResponse, type CacheConfig, type CacheConfigOption, type CacheKeyGenerator, type CacheStorage, type CachedResponse, type ClientConfig, type ErrorHandler, type ErrorInterceptor, type Interceptors, type RequestConfig, type RequestHandler, type RequestInterceptor, type ResponseHandler, type ResponseInterceptor, type RetryConfig, type RetryConfigOption, cleanupCircuitBreakers, cleanupPendingRequests, cleanupRetryAttempts, createClient, createPublicClient, getMemoryStats };