type RequestStatus = "PENDING" | "SUCCESS" | "FAILED" | "RETRYING" | "CANCELED" | "QUEUED";
interface ApiRequest<T = any> {
    id: string;
    url: string;
    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
    data?: T;
    params?: Record<string, any>;
    headers?: Record<string, string>;
    options: RequestOptions;
    status: RequestStatus;
    priority: number;
    createdAt: number;
    lastAttemptAt?: number;
    retryCount: number;
    resolve: (response: ApiResponse) => void;
    reject: (error: ApiError) => void;
}
interface ApiResponse<T = any> {
    data: T;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    config: ApiRequest;
    requestTime: number;
}
interface ApiError extends Error {
    isNetworkError: boolean;
    isTimeoutError: boolean;
    isRateLimitError: boolean;
    isServerError: boolean;
    isClientError: boolean;
    response?: ApiResponse;
    request?: ApiRequest;
    classification: "NETWORK" | "TIMEOUT" | "RATE_LIMIT" | "SERVER" | "CLIENT" | "UNKNOWN";
}
interface ApiClientConfig {
    baseUrl?: string;
    debug?: boolean;
    defaultHeaders?: Record<string, string>;
    retry: {
        maxAttempts: number;
        delayMs: number;
        statusCodes: number[];
    };
    rateLimit: {
        maxRequests: number;
        perMilliseconds: number;
    };
    offline: {
        enabled: boolean;
        storageKey: string;
        limit: number;
    };
    queue: {
        concurrency: number;
    };
    requestOptions: RequestOptions;
    adapter: "axios" | "fetch";
}
interface RequestOptions {
    timeout?: number;
    priority?: number;
    retryable?: boolean;
    offlineable?: boolean;
    cancelToken?: {
        promise: Promise<void>;
        onCancel?: () => void;
    };
    headers?: Record<string, string>;
}
interface Logger {
    log: (...args: any[]) => void;
    warn: (...args: any[]) => void;
    error: (...args: any[]) => void;
}

interface RequestAdapter {
    /**
     * Initializes the adapter with global configuration (e.g., setting up Axios instance).
     * @param config The global API client configuration.
     */
    initialize(config: ApiClientConfig): void;
    /**
     * Executes the API request.
     * @param request The complete ApiRequest object.
     * @returns {Promise<ApiResponse>} The structured API response.
     * @throws {ApiError} Throws a structured ApiError on failure (network, server, etc.).
     */
    execute(request: ApiRequest): Promise<ApiResponse>;
}

declare class AxiosAdapter implements RequestAdapter {
    private instance;
    initialize(config: ApiClientConfig): void;
    execute(request: ApiRequest): Promise<ApiResponse>;
    private normalizeError;
}

declare class RateLimiter {
    private maxRequests;
    private perMilliseconds;
    private requestTimestamps;
    constructor(config: ApiClientConfig);
    private cleanupTimestamps;
    /**
     * Checks if the rate limit has been hit and calculates the required delay.
     * @returns {number} The delay in milliseconds required before the next request can fire.
     * Returns 0 if no delay is needed.
     */
    checkLimitAndGetDelay(): number;
    recordRequestStart(): void;
}

declare class ApiClient {
    private config;
    private adapter;
    private retryStrategy;
    private rateLimiter;
    private offlineStore;
    private requestQueue;
    /**
     * Initializes the ApiClient with configuration and sets up core components.
     * @param userConfig - Optional user-provided configuration object.
     */
    constructor(userConfig?: Partial<ApiClientConfig>);
    private selectAdapter;
    private createApiRequest;
    /**
     * Executes the request through the adapter and handles success/failure.
     * This is the function passed to the RequestQueue.
     * @param request The request object to execute.
     */
    private executeRequestWithHandling;
    enqueueRequest: (request: ApiRequest) => void;
    /**
     * HTTP GET request.
     * @param url - The request URL.
     * @param params - Query parameters (data).
     * @param options - Request options.
     */
    get(url: string, paramsOrOptions?: Record<string, any> | RequestOptions, options?: RequestOptions): Promise<ApiResponse>;
    /**
     * HTTP POST request.
     * @param url - The request URL.
     * @param data - The request body.
     * @param options - Request options.
     */
    post<T>(url: string, data?: T, options?: RequestOptions): Promise<ApiResponse>;
    put<T>(url: string, data?: T, options?: RequestOptions): Promise<ApiResponse>;
    delete(url: string, data?: any, options?: RequestOptions): Promise<ApiResponse>;
    getRateLimiter(): RateLimiter;
    syncOfflineRequests(): Promise<void>;
}

export { ApiClient, type ApiClientConfig, type ApiError, type ApiRequest, type ApiResponse, AxiosAdapter, type Logger, type RequestOptions, type RequestStatus };