import { default as React } from 'react';
import { Disposable } from '../utils/memoryManager';
import { useMountedState } from './shared/useIsMounted';
/**
 * Hook for managing disposable resources with automatic cleanup
 * Cleans up all registered resources when component unmounts
 */
export declare function useDisposable(): {
    register: <T extends Disposable>(disposable: T) => T;
    registerFn: (cleanup: () => void) => Disposable;
    unregister: (disposable: Disposable) => void;
    disposeAll: () => void;
};
/**
 * Hook for managing abort controllers with automatic cleanup
 */
export declare function useAbortController(): {
    getSignal: () => AbortSignal;
    abort: (reason?: string) => void;
    reset: () => AbortController;
};
/**
 * Hook for managing timeouts with automatic cleanup
 */
export declare function useTimeout(): {
    set: (callback: () => void, delay: number) => number;
    clear: (id: number) => void;
    clearAll: () => void;
};
/**
 * Hook for managing intervals with automatic cleanup
 */
export declare function useInterval(): {
    set: (callback: () => void, delay: number) => number;
    clear: (id: number) => void;
    clearAll: () => void;
};
/**
 * Hook for managing event listeners with automatic cleanup
 */
export declare function useEventListener(): {
    add: <K extends keyof WindowEventMap>(target: EventTarget, type: K, listener: (event: WindowEventMap[K]) => void, options?: boolean | AddEventListenerOptions) => () => void;
    remove: (cleanup: () => void) => void;
    removeAll: () => void;
};
/**
 * Hook for managing subscriptions with automatic cleanup
 */
export declare function useSubscription(): {
    subscribe: <T>(subscribe: (callback: (value: T) => void) => () => void, callback: (value: T) => void) => () => void;
    unsubscribe: (cleanup: () => void) => void;
    unsubscribeAll: () => void;
};
/**
 * Hook for running cleanup effect on unmount
 */
export declare function useUnmountEffect(effect: () => void): void;
/**
 * Hook for tracking mounted state
 * @deprecated Use useMountedState from shared utilities instead
 */
export { useMountedState as useMounted } from './shared/useIsMounted';
/**
 * Hook for safe state updates that prevent updates after unmount
 */
export declare function useSafeState<T>(initialValue: T): [T, (value: T | ((prev: T) => T)) => void];
/**
 * Hook for ref-based cleanup that runs synchronously
 */
export declare function useRefCleanup<T>(factory: () => T, cleanup: (value: T) => void): React.RefObject<T>;
/**
 * Hook for managing WebSocket connections with cleanup
 */
export declare function useWebSocketCleanup(url: string | (() => string), options?: {
    protocols?: string | string[];
    onOpen?: (event: Event) => void;
    onMessage?: (event: MessageEvent) => void;
    onError?: (event: Event) => void;
    onClose?: (event: CloseEvent) => void;
    reconnect?: boolean;
    reconnectInterval?: number;
    maxReconnectAttempts?: number;
}): {
    ws: WebSocket | null;
    send: (data: string | ArrayBuffer | Blob) => void;
    close: (code?: number, reason?: string) => void;
    reconnect: () => void;
    readyState: number;
};
/**
 * Hook for managing all resources with unified interface
 */
export declare function useResourceManager(): {
    disposable: ReturnType<typeof useDisposable>;
    abort: ReturnType<typeof useAbortController>;
    timeout: ReturnType<typeof useTimeout>;
    interval: ReturnType<typeof useInterval>;
    eventListener: ReturnType<typeof useEventListener>;
    subscription: ReturnType<typeof useSubscription>;
    mounted: ReturnType<typeof useMountedState>;
    cleanupAll: () => void;
};
/**
 * Hook for async operations with automatic cancellation
 */
export declare function useAsync<T, Args extends unknown[]>(asyncFn: (...args: Args) => Promise<T>, deps?: React.DependencyList): {
    execute: (...args: Args) => Promise<T | undefined>;
    cancel: () => void;
    loading: boolean;
    error: Error | null;
    value: T | undefined;
};