/**
 * Return type for the useAsync hook
 */
export interface UseAsyncReturn<T, Args extends unknown[] = unknown[]> {
    /**
     * Execute the async function with the provided arguments
     */
    execute: (...args: Args) => Promise<T | undefined>;
    /**
     * Whether the async operation is currently in progress
     */
    loading: boolean;
    /**
     * Error from the last failed async operation, or null if no error
     */
    error: Error | null;
    /**
     * Data from the last successful async operation, or null if not yet executed
     */
    data: T | null;
    /**
     * Reset the hook state to initial values
     */
    reset: () => void;
}
/**
 * Manages the state and lifecycle of async operations.
 * Provides loading, error, and data states, with the ability to execute and reset.
 *
 * @template T - The return type of the async function
 * @template Args - The argument types of the async function
 * @param asyncFunction - The async function to manage
 * @returns Object containing execute function and state values
 *
 * @example
 * ```tsx
 * function UserProfile({ userId }: { userId: string }) {
 *   const { execute, loading, error, data } = useAsync(fetchUser);
 *
 *   useEffect(() => {
 *     execute(userId);
 *   }, [userId, execute]);
 *
 *   if (loading) return <LoadingSpinner />;
 *   if (error) return <ErrorMessage error={error} />;
 *   if (!data) return null;
 *
 *   return <div>{data.name}</div>;
 * }
 * ```
 *
 * @example
 * ```tsx
 * function SearchComponent() {
 *   const [query, setQuery] = useState('');
 *   const { execute, loading, error, data, reset } = useAsync(searchAPI);
 *
 *   const handleSearch = async () => {
 *     if (query.trim()) {
 *       await execute(query);
 *     }
 *   };
 *
 *   const handleClear = () => {
 *     setQuery('');
 *     reset();
 *   };
 *
 *   return (
 *     <div>
 *       <input value={query} onChange={(e) => setQuery(e.target.value)} />
 *       <button onClick={handleSearch} disabled={loading}>
 *         {loading ? 'Searching...' : 'Search'}
 *       </button>
 *       <button onClick={handleClear}>Clear</button>
 *       {error && <ErrorDisplay error={error} />}
 *       {data && <ResultsList results={data} />}
 *     </div>
 *   );
 * }
 * ```
 *
 * @example
 * ```tsx
 * function FormSubmission() {
 *   const { execute, loading, error, data } = useAsync(submitForm);
 *   const [formData, setFormData] = useState({ name: '', email: '' });
 *
 *   const handleSubmit = async (e: React.FormEvent) => {
 *     e.preventDefault();
 *     const result = await execute(formData);
 *     if (result) {
 *       console.log('Form submitted successfully:', result);
 *     }
 *   };
 *
 *   return (
 *     <form onSubmit={handleSubmit}>
 *       <input
 *         value={formData.name}
 *         onChange={(e) => setFormData({ ...formData, name: e.target.value })}
 *       />
 *       <input
 *         value={formData.email}
 *         onChange={(e) => setFormData({ ...formData, email: e.target.value })}
 *       />
 *       <button type="submit" disabled={loading}>
 *         {loading ? 'Submitting...' : 'Submit'}
 *       </button>
 *       {error && <div className="error">{error.message}</div>}
 *       {data && <div className="success">Success!</div>}
 *     </form>
 *   );
 * }
 * ```
 */
export declare function useAsync<T, Args extends unknown[] = unknown[]>(asyncFunction: (...args: Args) => Promise<T>): UseAsyncReturn<T, Args>;
/**
 * Alternative version that immediately executes the async function on mount.
 * Useful for fetching data when a component mounts.
 *
 * @template T - The return type of the async function
 * @param asyncFunction - The async function to execute
 * @returns Object containing loading, error, data, and refetch function
 *
 * @example
 * ```tsx
 * function Dashboard() {
 *   const { loading, error, data, refetch } = useAsyncImmediate(() =>
 *     fetchDashboardData()
 *   );
 *
 *   if (loading) return <LoadingSpinner />;
 *   if (error) return <ErrorMessage error={error} onRetry={refetch} />;
 *
 *   return (
 *     <div>
 *       <DashboardView data={data} />
 *       <button onClick={refetch}>Refresh</button>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useAsyncImmediate<T>(asyncFunction: () => Promise<T>): {
    loading: boolean;
    error: Error | null;
    data: T | null;
    refetch: () => Promise<void>;
};
//# sourceMappingURL=useAsync.d.ts.map