import { default as React, Context, ReactNode, FC } from 'react';
import { BridgeManagerContext } from '../contexts/BridgeManagerContext';
import { ContextBridgeDefinition } from './types';
/**
 * Bridge configuration options.
 */
export interface BridgeOptions<TSource, TTarget> {
    /** Transform source to target value */
    transformer: (source: TSource) => TTarget;
    /** Update strategy */
    updateStrategy?: 'immediate' | 'batched' | 'debounced';
    /** Debounce/batch window (ms) */
    updateWindow?: number;
    /** Equality check for optimization */
    equalityFn?: (prev: TTarget, next: TTarget) => boolean;
    /** Debug mode */
    debug?: boolean;
}
/**
 * Composed context value type.
 */
export type ComposedContextValue<T extends Record<string, unknown>> = T;
/**
 * Context selector function.
 */
export type ContextSelector<TContext, TSelected> = (context: TContext) => TSelected;
/**
 * Implementation of the context bridge manager.
 *
 * @example
 * ```tsx
 * const bridge = new ContextBridgeImpl();
 *
 * // Register a bridge from Auth context to User context
 * bridge.registerBridge({
 *   id: 'auth-to-user',
 *   sourceContext: AuthContext,
 *   targetContext: UserContext,
 *   transformer: (auth) => ({
 *     id: auth.user?.id,
 *     name: auth.user?.name,
 *     isAdmin: auth.roles?.includes('admin'),
 *   }),
 *   updateStrategy: 'batched',
 * });
 * ```
 */
export declare class ContextBridgeImpl {
    /** Registered bridges */
    private readonly bridges;
    /** Pending batched updates */
    private pendingUpdates;
    /** Batch timer */
    private batchTimer;
    /** Batch window (ms) */
    private readonly batchWindow;
    /**
     * Creates a new context bridge manager.
     * @param batchWindow - Default batch window in ms
     */
    constructor(batchWindow?: number);
    /**
     * Registers a context bridge.
     * @template TSource - Source context type
     * @template TTarget - Target context type
     * @param definition - Bridge definition
     */
    registerBridge<TSource, TTarget>(definition: ContextBridgeDefinition<TSource, TTarget>): void;
    /**
     * Unregisters a context bridge.
     * @param id - Bridge ID
     */
    unregisterBridge(id: string): void;
    /**
     * Updates a bridge with new source value.
     * @param id - Bridge ID
     * @param sourceValue - New source value
     */
    updateBridge<TSource>(id: string, sourceValue: TSource): void;
    /**
     * Subscribes to bridge value changes.
     * @param id - Bridge ID
     * @param callback - Change callback
     * @returns Unsubscribe function
     */
    subscribe<TTarget>(id: string, callback: (value: TTarget) => void): () => void;
    /**
     * Gets current bridged value.
     * @param id - Bridge ID
     * @returns Current value or null
     */
    getValue<TTarget>(id: string): TTarget | null;
    /**
     * Disposes the bridge manager.
     */
    dispose(): void;
    /**
     * Schedules batch processing.
     */
    private scheduleBatch;
    /**
     * Processes batched updates.
     */
    private processBatch;
    /**
     * Notifies subscribers of a value change.
     */
    private notifySubscribers;
}
/**
 * Props for ContextBridgeProvider.
 */
export interface ContextBridgeProviderProps {
    /** Children to render */
    children: ReactNode;
    /** Optional custom bridge manager */
    manager?: ContextBridgeImpl;
}
/**
 * Provider component for context bridge manager.
 */
export declare const ContextBridgeProvider: FC<ContextBridgeProviderProps>;
/**
 * Hook to access the bridge manager.
 */
export declare function useBridgeManager(): import('../contexts/BridgeManagerContext').ContextBridgeImpl;
/**
 * Hook to consume a bridged context value.
 * @template TTarget - Target value type
 * @param bridgeId - Bridge ID
 * @returns Bridged value
 */
export declare function useBridgedContext<TTarget>(bridgeId: string): TTarget | null;
/**
 * Props for BridgeSource component.
 */
export interface BridgeSourceProps<TSource> {
    /** Bridge ID */
    bridgeId: string;
    /** Source context */
    context: Context<TSource | null>;
    /** Children to render */
    children: ReactNode;
}
/**
 * Component that bridges a source context to the bridge manager.
 */
export declare function BridgeSource<TSource>({ bridgeId, context, children, }: BridgeSourceProps<TSource>): React.JSX.Element;
/**
 * Props for BridgeConsumer component.
 */
export interface BridgeConsumerProps<TTarget> {
    /** Bridge ID */
    bridgeId: string;
    /** Render function */
    children: (value: TTarget | null) => ReactNode;
}
/**
 * Component that consumes a bridged context value.
 */
export declare function BridgeConsumer<TTarget>({ bridgeId, children, }: BridgeConsumerProps<TTarget>): React.JSX.Element;
/**
 * Creates a composed context from multiple source contexts.
 * @template T - Composed context type
 * @param config - Context configuration
 * @returns Composed context and provider
 */
export declare function createComposedContext<T extends Record<string, unknown>>(config: {
    displayName: string;
    sources: {
        [K in keyof T]: {
            context: Context<T[K] | null>;
            selector?: (value: T[K]) => unknown;
        };
    };
}): {
    Context: Context<T | null>;
    Provider: FC<{
        children: ReactNode;
    }>;
    useComposed: () => T;
};
/**
 * Hook to select from multiple contexts with optimization.
 * @template TResult - Result type
 * @param selector - Selector function receiving context getters
 * @param deps - Dependencies for the selector
 * @returns Selected value
 */
export declare function useMultiContextSelector<TResult>(selector: (getContext: <T>(context: Context<T | null>) => T | null) => TResult, deps: Array<Context<unknown>>): TResult;
/**
 * Props added by withBridgedContext HOC.
 */
export interface WithBridgedContextProps<T> {
    bridgedValue: T | null;
}
/**
 * HOC to inject bridged context value as prop.
 * @template P - Component props
 * @template T - Bridged value type
 * @param bridgeId - Bridge ID
 * @returns HOC function
 */
export declare function withBridgedContext<P extends WithBridgedContextProps<T>, T>(bridgeId: string): (Component: React.ComponentType<P>) => React.FC<Omit<P, keyof WithBridgedContextProps<T>>>;
/**
 * Gets the global context bridge manager.
 */
export declare function getContextBridgeManager(): ContextBridgeImpl;
/**
 * Sets the global context bridge manager.
 */
export declare function setContextBridgeManager(manager: ContextBridgeImpl): void;
/**
 * Resets the global context bridge manager.
 */
export declare function resetContextBridgeManager(): void;
export { BridgeManagerContext };