import { UseStreamPriorityResult, StreamPriority } from '../types';
/**
 * Options for the useStreamPriority hook.
 */
export interface UseStreamPriorityOptions {
    /**
     * Initial priority level.
     * @default StreamPriority.Normal
     */
    initialPriority?: StreamPriority;
    /**
     * Minimum priority level (highest allowed).
     * @default StreamPriority.Critical
     */
    minPriority?: StreamPriority;
    /**
     * Maximum priority level (lowest allowed).
     * @default StreamPriority.Low
     */
    maxPriority?: StreamPriority;
    /**
     * Callback when priority changes.
     */
    onPriorityChange?: (priority: StreamPriority) => void;
    /**
     * Auto-escalate on user interaction.
     * @default false
     */
    escalateOnInteraction?: boolean;
    /**
     * Auto-escalate when element becomes visible.
     * @default false
     */
    escalateOnVisible?: boolean;
    /**
     * Visibility threshold for auto-escalation.
     * @default 0.5
     */
    visibilityThreshold?: number;
    /**
     * Cooldown period before de-escalation in milliseconds.
     * @default 0
     */
    deescalateCooldown?: number;
}
/**
 * Hook for controlling stream priority.
 *
 * @description
 * Provides an interface for dynamically adjusting stream priority,
 * enabling responsive streaming based on user behavior and visibility.
 *
 * Features:
 * - Manual priority control
 * - Escalation and de-escalation helpers
 * - Optional auto-escalation on interaction
 * - Optional auto-escalation on visibility
 * - Priority bounds enforcement
 * - Cooldown support for de-escalation
 *
 * @param boundaryId - Boundary ID to control
 * @param options - Optional configuration
 * @returns Priority control interface
 *
 * @example
 * ```tsx
 * // Basic usage
 * const { priority, setPriority, escalate, deescalate } = useStreamPriority('content');
 *
 * // With options
 * const { priority, escalate } = useStreamPriority('content', {
 *   initialPriority: StreamPriority.Low,
 *   escalateOnInteraction: true,
 *   deescalateCooldown: 5000,
 * });
 *
 * // Manual control
 * setPriority(StreamPriority.High);
 *
 * // Incremental adjustment
 * escalate();   // Low -> Normal -> High -> Critical
 * deescalate(); // Critical -> High -> Normal -> Low
 * ```
 */
export declare function useStreamPriority(boundaryId: string, options?: UseStreamPriorityOptions): UseStreamPriorityResult;
/**
 * Extended result with additional controls.
 */
export interface UseExtendedStreamPriorityResult extends UseStreamPriorityResult {
    /** Whether at maximum priority (critical) */
    isMaxPriority: boolean;
    /** Whether at minimum priority (low) */
    isMinPriority: boolean;
    /** Set to maximum priority */
    maximize: () => void;
    /** Set to minimum priority */
    minimize: () => void;
    /** Reset to initial priority */
    reset: () => void;
    /** Priority value (0-3, lower is higher priority) */
    priorityValue: number;
    /** Props to spread on element for auto-escalation on hover */
    hoverProps: {
        onMouseEnter: () => void;
        onMouseLeave: () => void;
    };
    /** Props to spread on element for auto-escalation on focus */
    focusProps: {
        onFocus: () => void;
        onBlur: () => void;
    };
}
/**
 * Extended stream priority hook with additional controls.
 *
 * @description
 * Provides all the functionality of useStreamPriority plus
 * additional convenience methods and computed values.
 *
 * @example
 * ```tsx
 * function InteractiveCard({ boundaryId }: { boundaryId: string }) {
 *   const {
 *     priority,
 *     isMaxPriority,
 *     maximize,
 *     reset,
 *     hoverProps,
 *     focusProps,
 *   } = useExtendedStreamPriority(boundaryId);
 *
 *   return (
 *     <div {...hoverProps} {...focusProps}>
 *       <p>Priority: {priority}</p>
 *       <button onClick={maximize} disabled={isMaxPriority}>
 *         Maximize Priority
 *       </button>
 *       <button onClick={reset}>Reset</button>
 *     </div>
 *   );
 * }
 * ```
 */
export declare function useExtendedStreamPriority(boundaryId: string, options?: UseStreamPriorityOptions): UseExtendedStreamPriorityResult;
/**
 * Hook for critical priority streams.
 *
 * @description
 * Pre-configured for critical priority with no ability
 * to de-escalate below high priority.
 */
export declare function useCriticalPriority(boundaryId: string, options?: Omit<UseStreamPriorityOptions, 'initialPriority' | 'maxPriority'>): UseStreamPriorityResult;
/**
 * Hook for deferred priority streams.
 *
 * @description
 * Pre-configured for low priority with ability
 * to escalate on interaction.
 */
export declare function useDeferredPriority(boundaryId: string, options?: Omit<UseStreamPriorityOptions, 'initialPriority'>): UseStreamPriorityResult;