import { default as React, ComponentType, ReactNode, LazyExoticComponent } from 'react';
/**
 * Module loader function type
 */
export type ModuleLoader<T = unknown> = () => Promise<{
    default: T;
} | T>;
/**
 * Component module loader
 */
export type ComponentLoader<P = unknown> = () => Promise<{
    default: ComponentType<P>;
}>;
/**
 * Module load result
 */
export interface ModuleLoadResult<T> {
    /** Loaded module or component */
    readonly module: T | null;
    /** Whether module is loading */
    readonly isLoading: boolean;
    /** Load error if any */
    readonly error: Error | null;
    /** Whether the flag-enabled module was loaded */
    readonly isEnabledVariant: boolean;
    /** Reload the module */
    reload(): void;
}
/**
 * Flagged module configuration
 */
export interface FlaggedModuleConfig<T> {
    /** Feature flag key */
    readonly flagKey: string;
    /** Module to load when flag is enabled */
    readonly enabledModule: ModuleLoader<T>;
    /** Module to load when flag is disabled (optional) */
    readonly fallbackModule?: ModuleLoader<T>;
    /** Default value if no fallback */
    readonly defaultValue?: T;
    /** Timeout for module loading (ms) */
    readonly timeout?: number;
    /** Retry configuration */
    readonly retry?: {
        attempts: number;
        delay: number;
    };
    /** Flag value getter */
    readonly getFlag?: (flagKey: string) => boolean;
    /** Preload on mount even if flag is disabled */
    readonly preload?: boolean;
    /** Cache loaded modules */
    readonly cache?: boolean;
}
/**
 * Flagged component props
 */
export interface FlaggedComponentProps<P = Record<string, unknown>> {
    /** Feature flag key */
    readonly flagKey: string;
    /** Component to load when flag is enabled */
    readonly enabledComponent: ComponentLoader<P>;
    /** Component to render when flag is disabled */
    readonly fallbackComponent?: ComponentType<P>;
    /** Props to pass to the component */
    readonly componentProps?: P;
    /** Loading fallback */
    readonly loadingFallback?: ReactNode;
    /** Error fallback */
    readonly errorFallback?: ReactNode | ((error: Error) => ReactNode);
    /** Flag value getter */
    readonly getFlag?: (flagKey: string) => boolean;
}
/**
 * Module preload configuration
 */
export interface ModulePreloadConfig {
    /** Module to preload */
    readonly module: ModuleLoader;
    /** Associated flag key */
    readonly flagKey?: string;
    /** Preload priority */
    readonly priority?: 'high' | 'low' | 'idle';
    /** Delay before preloading (ms) */
    readonly delay?: number;
}
/**
 * Clear module cache
 */
export declare function clearModuleCache(): void;
/**
 * Get module cache stats
 */
export declare function getModuleCacheStats(): {
    size: number;
    entries: {
        key: string;
        loadedAt: number;
        flagEnabled: boolean;
    }[];
};
/**
 * Hook to load a module based on feature flag state
 *
 * @example
 * ```typescript
 * const { module: Chart, isLoading } = useFeatureFlaggedModule({
 *   flagKey: 'new-charts',
 *   enabledModule: () => import('./charts/NewChart'),
 *   fallbackModule: () => import('./charts/OldChart'),
 * });
 * ```
 */
export declare function useFeatureFlaggedModule<T>(config: FlaggedModuleConfig<T>): ModuleLoadResult<T>;
/**
 * Hook to create a lazy component based on feature flag
 */
export declare function useFlaggedLazyComponent<P = Record<string, unknown>>(config: Omit<FlaggedModuleConfig<ComponentType<P>>, 'defaultValue'>): {
    Component: LazyExoticComponent<ComponentType<P>> | null;
    isEnabledVariant: boolean;
};
/**
 * Component that loads and renders a flagged module
 */
export declare function FlaggedModuleLoader<P extends Record<string, unknown> = Record<string, unknown>>({ flagKey, enabledComponent, fallbackComponent: FallbackComponent, componentProps, loadingFallback, errorFallback, getFlag, }: FlaggedComponentProps<P>): React.JSX.Element | null;
/**
 * Suspense-enabled flagged component loader
 */
export declare function SuspenseFlaggedLoader<P extends Record<string, unknown> = Record<string, unknown>>({ flagKey, enabledComponent, fallbackComponent, componentProps, loadingFallback, getFlag, }: Omit<FlaggedComponentProps<P>, 'errorFallback'>): React.JSX.Element;
/**
 * Create a flagged component that auto-loads based on flag state
 */
export declare function createFlaggedComponent<P extends Record<string, unknown> = Record<string, unknown>>(config: {
    flagKey: string;
    enabledComponent: ComponentLoader<P>;
    fallbackComponent?: ComponentType<P>;
    loadingFallback?: ReactNode;
    getFlag?: (flagKey: string) => boolean;
}): ComponentType<P>;
/**
 * Create multiple flagged components from a configuration object
 */
export declare function createFlaggedComponents<TComponents extends Record<string, ComponentLoader>>(config: {
    components: TComponents;
    fallbacks?: Partial<Record<keyof TComponents, ComponentType>>;
    loadingFallback?: ReactNode;
    getFlag?: (flagKey: string) => boolean;
}): {
    [K in keyof TComponents]: ComponentType;
};
/**
 * Preload a module in idle time
 */
export declare function preloadModule(config: ModulePreloadConfig): () => void;
/**
 * Preload multiple modules
 */
export declare function preloadModules(configs: ModulePreloadConfig[]): () => void;
/**
 * Create a preload link for a module
 */
export declare function createModulePreloadLink(moduleUrl: string): HTMLLinkElement;
/**
 * Configuration for route-based flagged loading
 */
export interface FlaggedRouteModuleConfig<T> {
    /** Route path pattern */
    readonly path: string;
    /** Feature flag key */
    readonly flagKey: string;
    /** Module to load when flag is enabled */
    readonly enabledModule: ModuleLoader<T>;
    /** Module to load when flag is disabled */
    readonly fallbackModule: ModuleLoader<T>;
}
/**
 * Create route loaders that respect feature flags
 */
export declare function createFlaggedRouteLoaders<T>(routes: FlaggedRouteModuleConfig<T>[], getFlag: (flagKey: string) => boolean): Map<string, () => Promise<T>>;