import { default as React, ReactNode } from 'react';
import { DOMContext, DOMContextProviderProps } from './types';
/**
 * React context for DOM context state.
 */
export declare const DOMContextReactContext: React.Context<DOMContext>;
/**
 * React context for DOM context update function.
 */
export declare const DOMContextUpdateContext: React.Context<(() => void) | null>;
/**
 * Provides DOM context to descendant components.
 *
 * @remarks
 * This is the main provider component that should wrap your application
 * or the parts of your application that need DOM context awareness.
 *
 * @example
 * ```tsx
 * // Basic usage
 * <DOMContextProvider>
 *   <App />
 * </DOMContextProvider>
 *
 * // With options
 * <DOMContextProvider
 *   updateDebounceMs={100}
 *   trackScrollContainers={true}
 *   onContextUpdate={(ctx) => console.log('Context updated:', ctx)}
 * >
 *   <App />
 * </DOMContextProvider>
 * ```
 */
export declare function DOMContextProvider({ children, className, style, initialViewport, updateDebounceMs, trackScrollContainers, trackZIndex, onContextUpdate, 'data-testid': testId, }: DOMContextProviderProps): React.JSX.Element;
/**
 * Props for DOMContextConsumer render prop component.
 */
export interface DOMContextConsumerProps {
    children: (context: DOMContext) => ReactNode;
}
/**
 * Render prop component for consuming DOM context.
 *
 * @example
 * ```tsx
 * <DOMContextConsumer>
 *   {(context) => (
 *     <div>
 *       Viewport: {context.viewport.width}x{context.viewport.height}
 *     </div>
 *   )}
 * </DOMContextConsumer>
 * ```
 */
export declare function DOMContextConsumer({ children }: DOMContextConsumerProps): React.JSX.Element;
/**
 * Hook to access the full DOM context.
 *
 * @returns Current DOMContext
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const context = useDOMContextValue();
 *   return <div>Initialized: {context.isInitialized}</div>;
 * }
 * ```
 */
export declare function useDOMContextValue(): DOMContext;
/**
 * Hook to get the context update function.
 *
 * @returns Update function or null
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const refresh = useDOMContextRefresh();
 *   return <button onClick={() => refresh?.()}>Refresh</button>;
 * }
 * ```
 */
export declare function useDOMContextRefresh(): (() => void) | null;
/**
 * Props injected by withDOMContext HOC.
 */
export interface WithDOMContextProps {
    domContext: DOMContext;
}
/**
 * Higher-order component that injects DOM context as a prop.
 *
 * @param Component - Component to wrap
 * @returns Wrapped component with DOM context
 *
 * @example
 * ```tsx
 * interface MyComponentProps extends WithDOMContextProps {
 *   title: string;
 * }
 *
 * function MyComponent({ title, domContext }: MyComponentProps) {
 *   return (
 *     <div>
 *       {title} - {domContext.viewport.width}px
 *     </div>
 *   );
 * }
 *
 * export default withDOMContext(MyComponent);
 * ```
 */
export declare function withDOMContext<P extends WithDOMContextProps>(Component: React.ComponentType<P>): React.ComponentType<Omit<P, 'domContext'>>;
/**
 * Props for NestedDOMContextProvider.
 */
export interface NestedDOMContextProviderProps extends Omit<DOMContextProviderProps, 'initialViewport'> {
    /** Whether to inherit from parent context */
    inheritParent?: boolean;
}
/**
 * Nested DOM context provider that can optionally inherit from parent.
 *
 * @remarks
 * Use this when you need a sub-tree to have its own DOM context
 * while optionally inheriting some state from the parent context.
 *
 * @example
 * ```tsx
 * <DOMContextProvider>
 *   <NestedDOMContextProvider inheritParent>
 *     <MyComponent />
 *   </NestedDOMContextProvider>
 * </DOMContextProvider>
 * ```
 */
export declare function NestedDOMContextProvider({ children, inheritParent, ...props }: NestedDOMContextProviderProps): React.JSX.Element;
/**
 * Hook to select a specific part of DOM context with memoization.
 *
 * @param selector - Selector function
 * @returns Selected value
 *
 * @example
 * ```tsx
 * function MyComponent() {
 *   const viewport = useDOMContextSelector((ctx) => ctx.viewport);
 *   const isInitialized = useDOMContextSelector((ctx) => ctx.isInitialized);
 *
 *   return <div>Width: {viewport.width}</div>;
 * }
 * ```
 */
export declare function useDOMContextSelector<T>(selector: (context: DOMContext) => T): T;