import { prepass, getFields, getArrayFields, selectFields, castNotSkeleton, castNotSkeletonDeep } from 'gqless';
import { BuildSelectionInput, GQlessError, ResolveOptions, Selection } from 'gqless';
import { ProxyAccessor } from 'gqless/dist/Cache';
import { EventHandler } from 'gqless/dist/Events';
import { InterceptorManager } from 'gqless/dist/Interceptor';
import { Scheduler } from 'gqless/dist/Scheduler';
import { MutableRefObject, useEffect, useLayoutEffect } from 'react';
export declare function useOnFirstMount(fn: () => void): void;
export declare const IS_BROWSER: boolean;
export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
export declare function useForceUpdate(): (() => void) & {
    wasCalled: MutableRefObject<boolean>;
};
export declare function useLazyRef<T>(initialValFunc: () => T): MutableRefObject<T>;
export declare const useUpdateEffect: typeof useEffect;
export declare function useIsRendering(): MutableRefObject<boolean>;
export declare function useIsMounted(): MutableRefObject<boolean>;
export declare function useDeferDispatch<F extends (...args: any[]) => void>(dispatchFn: F): F;
export declare type FetchPolicy = 'cache-and-network' | 'cache-first' | 'network-only' | 'no-cache';
export declare function fetchPolicyDefaultResolveOptions(fetchPolicy: FetchPolicy | undefined): ResolveOptions<unknown>;
export declare type BuildSelections<T> = (Selection | BuildSelectionInput | T)[];
export declare function useBuildSelections(argSelections: BuildSelections<never> | null | undefined, buildSelection: (...args: BuildSelectionInput) => Selection, getProxySelection: (proxy: ProxyAccessor) => Selection | undefined, caller: Function): {
    selections: Set<Selection>;
    hasSpecifiedSelections: boolean;
};
export declare type List<T> = Set<T> | Array<T>;
export declare function toSetIfNeeded<T>(list: List<T>): Set<T>;
export declare function isSelectionIncluded(selection: Selection, selectionList: List<Selection>): boolean;
export declare function isAnySelectionIncluded(selectionsToCheck: List<Selection>, selectionsList: List<Selection>): boolean;
export declare function isAnySelectionIncludedInMatrix(selectionsToCheck: List<Selection>, selectionsMatrix: List<List<Selection>>): boolean;
export declare function useSelectionsState(): Set<Selection>;
export declare function useSubscribeCacheChanges({ hookSelections, eventHandler, onChange, shouldSubscribe, }: {
    hookSelections: Set<Selection>;
    eventHandler: EventHandler;
    onChange: () => void;
    shouldSubscribe?: boolean;
}): void;
export declare function useInterceptSelections({ interceptorManager: { globalInterceptor, createInterceptor, removeInterceptor, }, staleWhileRevalidate, scheduler, eventHandler, onError, updateOnFetchPromise, }: {
    staleWhileRevalidate: boolean | object | number | string | null;
    interceptorManager: InterceptorManager;
    scheduler: Scheduler;
    eventHandler: EventHandler;
    onError: OnErrorHandler | undefined;
    updateOnFetchPromise?: boolean;
}): {
    fetchingPromise: MutableRefObject<Promise<void> | null>;
    unsubscribe: () => void;
};
export declare function useSuspensePromise(optsRef: {
    current: {
        suspense?: boolean;
    };
}): (promise: Promise<unknown>, inlineThrow?: boolean | undefined) => void;
export declare type OnErrorHandler = (error: GQlessError) => void;
export interface CoreHelpers {
    prepass: typeof prepass;
    getFields: typeof getFields;
    getArrayFields: typeof getArrayFields;
    selectFields: typeof selectFields;
    castNotSkeleton: typeof castNotSkeleton;
    castNotSkeletonDeep: typeof castNotSkeletonDeep;
}
export declare const coreHelpers: CoreHelpers;
export declare function uniqBy<TNode>(list: TNode[], cb?: (node: TNode) => unknown): TNode[];
export declare function sortBy<TNode>(list: TNode[], cb: (node: TNode) => number | string, order?: 'asc' | 'desc'): TNode[];