import { QueryKey, UseQueryResult } from '@tanstack/react-query';
import { ApiError, RequestConfig, QueryParams, UseApiRequestOptions } from '../types';
/**
 * API request configuration
 */
export interface ApiRequestConfig<TResponse = unknown> {
    /** Request URL (relative to base URL) */
    url: string;
    /** Query key for caching */
    queryKey: QueryKey;
    /** Path parameters for URL substitution */
    pathParams?: Record<string, string | number>;
    /** Query parameters */
    params?: QueryParams;
    /** Additional request options */
    requestOptions?: Partial<RequestConfig>;
    /** Transform response data */
    select?: (data: TResponse) => TResponse;
}
/**
 * Combined options for useApiRequest
 */
export type ApiRequestOptions<TResponse> = ApiRequestConfig<TResponse> & UseApiRequestOptions<TResponse>;
/**
 * Return type for useApiRequest
 */
export interface UseApiRequestResult<TData> extends Omit<UseQueryResult<TData, ApiError>, 'data'> {
    /** Response data (undefined while loading) */
    data: TData | undefined;
    /** Whether data exists */
    hasData: boolean;
    /** Invalidate and refetch */
    invalidate: () => Promise<void>;
    /** Update data in cache */
    setData: (updater: TData | ((old: TData | undefined) => TData)) => void;
    /** Get current cached data */
    getCachedData: () => TData | undefined;
}
/**
 * Hook for making typed API GET requests with caching
 *
 * @typeParam TResponse - Expected response data type
 * @param options - Request and query configuration
 * @returns Query result with additional utilities
 *
 * @example
 * ```typescript
 * // Basic usage
 * const { data, isLoading } = useApiRequest<User>({
 *   url: '/users/123',
 *   queryKey: ['users', '123'],
 * });
 *
 * // With options
 * const { data, refetch } = useApiRequest<User[]>({
 *   url: '/users',
 *   queryKey: ['users', 'list', filters],
 *   params: { page: 1, limit: 20 },
 *   staleTime: 60000,
 *   enabled: isAuthenticated,
 *   onSuccess: (users) => console.log('Loaded users:', users.length),
 * });
 *
 * // With path params
 * const { data } = useApiRequest<Post[]>({
 *   url: '/users/:userId/posts',
 *   queryKey: ['users', userId, 'posts'],
 *   pathParams: { userId },
 * });
 * ```
 */
export declare function useApiRequest<TResponse = unknown>(options: ApiRequestOptions<TResponse>): UseApiRequestResult<TResponse>;
/**
 * Simpler hook for basic GET requests
 *
 * @example
 * ```typescript
 * const { data, isLoading } = useGet<User>('/users/123', ['users', '123']);
 * ```
 */
export declare function useGet<TResponse = unknown>(url: string, queryKey: QueryKey, options?: Omit<ApiRequestOptions<TResponse>, 'url' | 'queryKey'>): UseApiRequestResult<TResponse>;
/**
 * Hook for fetching a resource by ID
 *
 * @example
 * ```typescript
 * const { data, isLoading } = useGetById<User>('/users', '123');
 * ```
 */
export declare function useGetById<TResponse = unknown>(baseUrl: string, id: string | undefined, options?: Omit<ApiRequestOptions<TResponse>, 'url' | 'queryKey'>): UseApiRequestResult<TResponse>;
/**
 * Hook for fetching a list with pagination
 *
 * @example
 * ```typescript
 * const { data, isLoading } = useGetList<User>('/users', {
 *   page: 1,
 *   pageSize: 20,
 *   filters: { status: 'active' },
 * });
 * ```
 */
export declare function useGetList<TResponse = unknown>(url: string, params?: {
    page?: number;
    pageSize?: number;
    filters?: Record<string, unknown>;
    sort?: string;
    order?: 'asc' | 'desc';
}, options?: Omit<ApiRequestOptions<TResponse>, 'url' | 'queryKey' | 'params'>): UseApiRequestResult<TResponse>;
/**
 * Result type for parallel requests
 */
export interface ParallelRequestResult<TData> {
    /** Response data (undefined while loading) */
    data: TData | undefined;
    /** Whether data exists */
    hasData: boolean;
    /** Is loading */
    isLoading: boolean;
    /** Is fetching */
    isFetching: boolean;
    /** Error if any */
    error: ApiError | null;
    /** Is error state */
    isError: boolean;
    /** Is success state */
    isSuccess: boolean;
}
/**
 * Hook for making multiple parallel requests
 *
 * Uses useQueries from TanStack Query to properly execute parallel requests
 * without violating Rules of Hooks.
 *
 * @example
 * ```typescript
 * const results = useParallelRequests([
 *   { url: '/users', queryKey: ['users'] },
 *   { url: '/posts', queryKey: ['posts'] },
 * ]);
 *
 * const [usersResult, postsResult] = results;
 * if (usersResult.isLoading || postsResult.isLoading) {
 *   return <Spinner />;
 * }
 * ```
 */
export declare function useParallelRequests<TResponses extends unknown[]>(requests: {
    [K in keyof TResponses]: ApiRequestOptions<TResponses[K]>;
}): {
    [K in keyof TResponses]: ParallelRequestResult<TResponses[K]>;
};
/**
 * Hook for making dependent sequential requests
 *
 * @example
 * ```typescript
 * const { data: posts } = useDependentRequest<User, Post[]>(
 *   { url: '/users/123', queryKey: ['users', '123'] },
 *   (user) => ({
 *     url: `/users/${user.id}/posts`,
 *     queryKey: ['users', user.id, 'posts'],
 *   })
 * );
 * ```
 */
export declare function useDependentRequest<TFirst, TSecond>(firstRequest: ApiRequestOptions<TFirst>, secondRequestFn: (data: TFirst) => ApiRequestOptions<TSecond>): {
    first: UseApiRequestResult<TFirst>;
    second: UseApiRequestResult<TSecond>;
    isLoading: boolean;
    error: ApiError | null;
};
/**
 * Hook for polling an endpoint at regular intervals
 *
 * @example
 * ```typescript
 * const { data, stopPolling, startPolling } = usePolling<JobStatus>({
 *   url: `/jobs/${jobId}/status`,
 *   queryKey: ['jobs', jobId, 'status'],
 *   interval: 5000,
 *   stopCondition: (data) => data.status === 'completed',
 * });
 * ```
 */
export declare function usePolling<TResponse = unknown>(options: ApiRequestOptions<TResponse> & {
    interval: number;
    stopCondition?: (data: TResponse) => boolean;
}): UseApiRequestResult<TResponse> & {
    isPolling: boolean;
    startPolling: () => void;
    stopPolling: () => void;
};
/**
 * Hook for prefetching data
 *
 * @example
 * ```typescript
 * const prefetch = usePrefetch<User>();
 *
 * // On hover
 * <Link onMouseEnter={() => prefetch('/users/123', ['users', '123'])}>
 *   User Profile
 * </Link>
 * ```
 */
export declare function usePrefetch<TResponse = unknown>(): (url: string, queryKey: QueryKey, options?: Partial<ApiRequestOptions<TResponse>>) => Promise<void>;
/**
 * Hook for lazy/manual queries (not executed automatically)
 *
 * @example
 * ```typescript
 * const { execute, data, isLoading } = useLazyQuery<User>({
 *   url: '/users/:id',
 *   queryKey: ['users'],
 * });
 *
 * // Execute manually
 * const handleClick = async (userId: string) => {
 *   const user = await execute({ pathParams: { id: userId } });
 *   console.log(user);
 * };
 * ```
 */
export declare function useLazyQuery<TResponse = unknown>(options: Omit<ApiRequestOptions<TResponse>, 'enabled'>): UseApiRequestResult<TResponse> & {
    execute: (overrides?: Partial<ApiRequestOptions<TResponse>>) => Promise<TResponse>;
};