import { DependencyList } from 'react';
/**
 * Hook state representation.
 */
export interface HookState<T> {
    /** Data value */
    data: T | undefined;
    /** Loading state */
    isLoading: boolean;
    /** Error state */
    error: Error | null;
    /** Last updated timestamp */
    lastUpdated: number | null;
}
/**
 * Composed hooks result.
 */
export interface ComposedResult<T extends Record<string, unknown>> {
    /** Combined data from all hooks */
    data: T;
    /** Whether any hook is loading */
    isLoading: boolean;
    /** Whether all hooks have loaded at least once */
    isReady: boolean;
    /** First error encountered */
    error: Error | null;
    /** All errors by hook key */
    errors: Partial<Record<keyof T, Error | null>>;
    /** Loading states by hook key */
    loadingStates: Record<keyof T, boolean>;
    /** Refresh all hooks */
    refresh: () => void;
    /** Refresh specific hook */
    refreshKey: (key: keyof T) => void;
}
/**
 * Hook definition for composition.
 */
export interface HookDef<T> {
    /** Hook function */
    hook: () => T;
    /** Optional selector to extract value from hook result */
    selector?: (result: T) => unknown;
    /** Whether hook is enabled */
    enabled?: boolean;
    /** Dependencies that must be ready first */
    dependsOn?: string[];
    /** Whether to suspend on loading */
    suspendOnLoading?: boolean;
}
/**
 * Async hook result format.
 */
export interface AsyncHookResult<T> {
    data: T | undefined;
    isLoading: boolean;
    error: Error | null;
    refetch?: () => void;
}
/**
 * Composition options.
 */
export interface CompositionOptions {
    /** Strategy for handling partial loading */
    loadingStrategy: 'all' | 'any' | 'none';
    /** Strategy for handling errors */
    errorStrategy: 'first' | 'all' | 'ignore';
    /** Enable debug logging */
    debug: boolean;
}
/**
 * Extracts the data type from a hook definition.
 */
type HookDataType<T> = T extends HookDef<infer R> ? R extends AsyncHookResult<infer D> ? D : T extends {
    selector: (r: R) => infer S;
} ? S : R : never;
/**
 * Maps hook definitions to their data types.
 */
type ComposedData<T extends Record<string, HookDef<unknown>>> = {
    [K in keyof T]: HookDataType<T[K]>;
};
/**
 * Composes multiple hooks into a single unified result.
 *
 * @template T - Hook definitions object type
 * @param definitions - Object mapping keys to hook definitions
 * @param options - Composition options
 * @returns Composed result
 *
 * @example
 * ```tsx
 * function Dashboard() {
 *   const { data, isLoading, error } = useComposedHooks({
 *     user: {
 *       hook: useCurrentUser,
 *       selector: (result) => result.data,
 *     },
 *     settings: {
 *       hook: useSettings,
 *       dependsOn: ['user'],
 *     },
 *     theme: {
 *       hook: useTheme,
 *     },
 *   });
 *
 *   if (isLoading) return <Loading />;
 *   if (error) return <Error error={error} />;
 *
 *   return (
 *     <div style={{ theme: data.theme }}>
 *       Welcome, {data.user.name}!
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useComposedHooks<T extends Record<string, HookDef<unknown>>>(definitions: T, options?: Partial<CompositionOptions>): ComposedResult<ComposedData<T>>;
/**
 * Composes hooks with selective re-rendering based on used keys.
 *
 * @template T - Hook definitions object type
 * @param definitions - Object mapping keys to hook definitions
 * @returns Proxy object that tracks accessed keys
 *
 * @example
 * ```tsx
 * function Profile() {
 *   const hooks = useSelectiveHooks({
 *     user: { hook: useCurrentUser },
 *     settings: { hook: useSettings },
 *   });
 *
 *   // Only re-renders when user changes, not settings
 *   return <div>{hooks.user?.name}</div>;
 * }
 * ```
 */
export declare function useSelectiveHooks<T extends Record<string, HookDef<unknown>>>(definitions: T): ComposedData<T> & {
    __meta: {
        accessedKeys: Set<keyof T>;
    };
};
/**
 * Conditionally executes hooks based on predicates.
 *
 * @template T - Data type
 * @param condition - Boolean or function returning boolean
 * @param hookFn - Hook function to execute
 * @param fallback - Fallback value when condition is false
 * @returns Hook result or fallback
 *
 * @example
 * ```tsx
 * function UserDashboard({ isAdmin }: { isAdmin: boolean }) {
 *   const adminData = useConditionalHook(
 *     isAdmin,
 *     useAdminData,
 *     { users: [], stats: null }
 *   );
 *
 *   return <div>{adminData.users.length} users</div>;
 * }
 * ```
 */
export declare function useConditionalHook<T>(condition: boolean | (() => boolean), hookFn: () => T, fallback: T): T;
/**
 * Creates a memoized hook composition that only updates when dependencies change.
 *
 * @template T - Result type
 * @param factory - Factory function that calls hooks
 * @param deps - Dependencies array
 * @returns Memoized result
 *
 * @example
 * ```tsx
 * function SearchResults({ query }: { query: string }) {
 *   const result = useMemoizedComposition(
 *     () => ({
 *       results: useSearchResults(query),
 *       suggestions: useSuggestions(query),
 *     }),
 *     [query]
 *   );
 *
 *   return <ResultsList items={result.results} />;
 * }
 * ```
 */
export declare function useMemoizedComposition<T>(factory: () => T, deps: DependencyList): T;
/**
 * Executes hooks in parallel and aggregates results.
 *
 * @template T - Hooks record type
 * @param hooks - Record of hook functions
 * @returns Aggregated results with loading/error states
 *
 * @example
 * ```tsx
 * function DataLoader() {
 *   const { data, isLoading, errors } = useParallelHooks({
 *     users: () => useUsers(),
 *     posts: () => usePosts(),
 *     comments: () => useComments(),
 *   });
 *
 *   if (isLoading) return <Spinner />;
 *
 *   return (
 *     <div>
 *       {data.users?.length} users
 *       {data.posts?.length} posts
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useParallelHooks<T extends Record<string, () => unknown>>(hooks: T): {
    data: {
        [K in keyof T]: ReturnType<T[K]> extends AsyncHookResult<infer D> ? D : ReturnType<T[K]>;
    };
    isLoading: boolean;
    errors: {
        [K in keyof T]: Error | null;
    };
};
/**
 * Executes hooks in sequence, passing results to subsequent hooks.
 *
 * @param steps - Array of step functions
 * @returns Final result and intermediate results
 *
 * @example
 * ```tsx
 * function OrderFlow() {
 *   const { result, steps } = useHookSequence([
 *     () => useCurrentUser(),
 *     (user) => useUserOrders(user.id),
 *     (orders) => useOrderDetails(orders[0]?.id),
 *   ]);
 *
 *   return <OrderDetails order={result} />;
 * }
 * ```
 */
export declare function useHookSequence<T>(steps: Array<(prevResult: unknown) => unknown>): {
    result: T;
    steps: unknown[];
    isComplete: boolean;
};
/**
 * Creates a hook definition with type inference.
 */
export declare function defineHook<T>(hook: () => T, options?: Omit<HookDef<T>, 'hook'>): HookDef<T>;
/**
 * Creates an async hook definition.
 */
export declare function defineAsyncHook<T>(hook: () => AsyncHookResult<T>, options?: Omit<HookDef<AsyncHookResult<T>>, 'hook'>): HookDef<AsyncHookResult<T>>;
export {};