import { UseDeferredStreamOptions, UseDeferredStreamResult } from '../types';
/**
 * Hook for deferring stream content.
 *
 * @description
 * Provides fine-grained control over when streaming should begin,
 * based on various conditions like visibility, idle state, or events.
 *
 * Deferral strategies:
 * - **Visibility**: Defer until element enters viewport
 * - **Idle**: Defer until browser is idle (requestIdleCallback)
 * - **Event**: Defer until a custom event is fired
 * - **Time-based**: Maximum defer duration before auto-triggering
 *
 * Features:
 * - Multiple deferral conditions (AND logic)
 * - Manual trigger override
 * - Maximum defer timeout
 * - Reason tracking for debugging
 * - Automatic cleanup
 *
 * @param options - Deferral configuration
 * @returns Deferral state and controls
 *
 * @example
 * ```tsx
 * // Defer until visible
 * const { isDeferred, ref } = useDeferredStream({
 *   deferUntilVisible: true,
 * });
 *
 * // Defer until browser is idle
 * const { isDeferred } = useDeferredStream({
 *   deferUntilIdle: true,
 * });
 *
 * // Defer until custom event
 * const { isDeferred } = useDeferredStream({
 *   deferUntilEvent: 'user-scrolled',
 * });
 *
 * // Combined conditions with timeout
 * const { isDeferred, ref, triggerNow, deferReason } = useDeferredStream({
 *   deferUntilVisible: true,
 *   deferUntilIdle: true,
 *   maxDeferMs: 3000,
 * });
 * ```
 */
export declare function useDeferredStream(options?: UseDeferredStreamOptions): UseDeferredStreamResult;
/**
 * Extended result with additional controls.
 */
export interface UseExtendedDeferredStreamResult extends UseDeferredStreamResult {
    /** Time remaining until max defer timeout */
    timeRemaining: number | null;
    /** Whether deferral is due to visibility */
    isDeferredByVisibility: boolean;
    /** Whether deferral is due to idle state */
    isDeferredByIdle: boolean;
    /** Whether deferral is due to event */
    isDeferredByEvent: boolean;
    /** Reset deferral state */
    reset: () => void;
}
/**
 * Extended deferred stream hook with additional information.
 *
 * @example
 * ```tsx
 * function DetailedDeferred() {
 *   const {
 *     isDeferred,
 *     isDeferredByVisibility,
 *     isDeferredByIdle,
 *     timeRemaining,
 *     ref,
 *     reset,
 *   } = useExtendedDeferredStream({
 *     deferUntilVisible: true,
 *     deferUntilIdle: true,
 *     maxDeferMs: 5000,
 *   });
 *
 *   return (
 *     <div ref={ref}>
 *       {isDeferred && (
 *         <div>
 *           <p>Waiting: {isDeferredByVisibility ? 'visibility' : 'idle'}</p>
 *           <p>Time remaining: {timeRemaining}ms</p>
 *           <button onClick={reset}>Reset</button>
 *         </div>
 *       )}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useExtendedDeferredStream(options?: UseDeferredStreamOptions): UseExtendedDeferredStreamResult;
/**
 * Hook for deferring until element is visible.
 *
 * @description
 * Convenience hook for visibility-based deferral.
 *
 * @example
 * ```tsx
 * function LazyImage({ src }: { src: string }) {
 *   const { isDeferred, ref } = useDeferUntilVisible();
 *
 *   return (
 *     <div ref={ref}>
 *       {isDeferred ? <Skeleton /> : <img src={src} />}
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useDeferUntilVisible(options?: Omit<UseDeferredStreamOptions, 'deferUntilVisible'>): UseDeferredStreamResult;
/**
 * Hook for deferring until browser is idle.
 *
 * @description
 * Convenience hook for idle-based deferral.
 *
 * @example
 * ```tsx
 * function NonCriticalWidget() {
 *   const { isDeferred } = useDeferUntilIdle();
 *
 *   if (isDeferred) return null;
 *
 *   return <ExpensiveWidget />;
 * }
 * ```
 */
export declare function useDeferUntilIdle(options?: Omit<UseDeferredStreamOptions, 'deferUntilIdle'>): UseDeferredStreamResult;
/**
 * Hook for deferring until a custom event.
 *
 * @description
 * Convenience hook for event-based deferral.
 *
 * @param eventName - Name of the event to wait for
 * @param options - Additional options
 *
 * @example
 * ```tsx
 * function AfterLoginContent() {
 *   const { isDeferred } = useDeferUntilEvent('user:logged-in');
 *
 *   if (isDeferred) return <LoginPrompt />;
 *
 *   return <AuthenticatedContent />;
 * }
 * ```
 */
export declare function useDeferUntilEvent(eventName: string, options?: Omit<UseDeferredStreamOptions, 'deferUntilEvent'>): UseDeferredStreamResult;