/**
 * @rajeev02/app-shell — API Client
 * Offline-first API layer with interceptors, token refresh, retry, cache-first strategy
 */
export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
export type CacheStrategy = "network_first" | "cache_first" | "network_only" | "cache_only" | "stale_while_revalidate";
export interface ApiConfig {
    baseUrl: string;
    timeout?: number;
    defaultHeaders?: Record<string, string>;
    /** Get current access token */
    getToken?: () => Promise<string | null>;
    /** Refresh token when 401 received */
    onRefreshToken?: () => Promise<string | null>;
    /** Called on network error (for queueing) */
    onNetworkError?: (request: ApiRequest) => void;
    /** Default cache strategy */
    defaultCacheStrategy?: CacheStrategy;
    /** Default cache TTL in seconds */
    defaultCacheTtl?: number;
}
export interface ApiRequest {
    method: HttpMethod;
    path: string;
    body?: unknown;
    headers?: Record<string, string>;
    query?: Record<string, string>;
    cacheStrategy?: CacheStrategy;
    cacheTtl?: number;
    retryCount?: number;
    maxRetries?: number;
    tag?: string;
}
export interface ApiResponse<T = unknown> {
    data: T;
    status: number;
    headers: Record<string, string>;
    fromCache: boolean;
    duration: number;
}
export interface RequestInterceptor {
    name: string;
    onRequest: (request: ApiRequest) => ApiRequest | Promise<ApiRequest>;
}
export interface ResponseInterceptor {
    name: string;
    onResponse: (response: ApiResponse) => ApiResponse | Promise<ApiResponse>;
    onError?: (error: unknown, request: ApiRequest) => unknown;
}
/**
 * Offline-First API Client
 */
export declare class ApiClient {
    private config;
    private requestInterceptors;
    private responseInterceptors;
    private pendingRequests;
    private cache;
    private isRefreshing;
    private refreshQueue;
    constructor(config: ApiConfig);
    /** Add request interceptor */
    addRequestInterceptor(interceptor: RequestInterceptor): void;
    /** Add response interceptor */
    addResponseInterceptor(interceptor: ResponseInterceptor): void;
    /** Main request method */
    request<T = unknown>(req: ApiRequest): Promise<ApiResponse<T>>;
    get<T = unknown>(path: string, query?: Record<string, string>, options?: Partial<ApiRequest>): Promise<ApiResponse<T>>;
    post<T = unknown>(path: string, body?: unknown, options?: Partial<ApiRequest>): Promise<ApiResponse<T>>;
    put<T = unknown>(path: string, body?: unknown, options?: Partial<ApiRequest>): Promise<ApiResponse<T>>;
    patch<T = unknown>(path: string, body?: unknown, options?: Partial<ApiRequest>): Promise<ApiResponse<T>>;
    delete<T = unknown>(path: string, options?: Partial<ApiRequest>): Promise<ApiResponse<T>>;
    /** Clear API cache */
    clearCache(): void;
    /** Get pending (queued) requests count */
    getPendingCount(): number;
    private fetchFromNetwork;
    private processResponse;
    private handleTokenRefresh;
    private getFromCache;
    private getCacheKey;
    private buildUrl;
}
//# sourceMappingURL=index.d.ts.map