import { default as React, ReactNode } from 'react';
import { checkWebPSupport, checkAVIFSupport, createFeature as createFeatureUtil, BrowserCapabilities } from './progressive-enhancement-utils';
import { useProgressiveEnhancement, useProgressiveFeature, useCapability, useCapabilities, useCapabilityConditional } from './progressive-enhancement-hooks';
/**
 * Feature capability levels
 */
export type CapabilityLevel = 'full' | 'partial' | 'fallback' | 'none';
export type { BrowserCapabilities } from './progressive-enhancement-utils';
/**
 * Feature definition
 */
export interface FeatureDefinition {
    /** Feature identifier */
    id: string;
    /** Human-readable name */
    name: string;
    /** Required capabilities */
    requires: Array<keyof BrowserCapabilities>;
    /** Optional capabilities for enhanced experience */
    enhancedBy?: Array<keyof BrowserCapabilities>;
    /** Loader function */
    loader: () => Promise<unknown>;
    /** Fallback loader */
    fallbackLoader?: () => Promise<unknown>;
    /** Polyfills to load */
    polyfills?: Array<() => Promise<void>>;
    /** Priority (higher = load first) */
    priority?: number;
}
/**
 * Feature status
 */
export interface FeatureStatus {
    /** Feature ID */
    id: string;
    /** Capability level */
    level: CapabilityLevel;
    /** Is loaded */
    loaded: boolean;
    /** Is loading */
    loading: boolean;
    /** Load error */
    error: Error | null;
    /** Loaded module */
    module: unknown;
}
export interface ProgressiveEnhancementProviderProps {
    children: ReactNode;
    /** Initial feature definitions */
    features?: FeatureDefinition[];
    /** On capability detection complete */
    onCapabilitiesDetected?: (capabilities: BrowserCapabilities) => void;
}
/**
 * Progressive enhancement provider
 */
export declare function ProgressiveEnhancementProvider({ children, features: initialFeatures, onCapabilitiesDetected, }: ProgressiveEnhancementProviderProps): React.ReactElement;
interface CapabilityGateProps {
    capability: keyof BrowserCapabilities;
    children: ReactNode;
    fallback?: ReactNode;
}
/**
 * Render children only if capability is supported
 */
export declare function CapabilityGate({ capability, children, fallback, }: CapabilityGateProps): React.ReactElement;
interface FeatureGateProps {
    featureId: string;
    children: ReactNode | ((module: unknown) => ReactNode);
    loading?: ReactNode;
    fallback?: ReactNode;
    errorFallback?: ReactNode | ((error: Error) => ReactNode);
}
/**
 * Render children when feature is loaded
 */
export declare function FeatureGate({ featureId, children, loading: loadingFallback, fallback, errorFallback, }: FeatureGateProps): React.ReactElement;
declare const _default: {
    ProgressiveEnhancementProvider: typeof ProgressiveEnhancementProvider;
    useProgressiveEnhancement: typeof useProgressiveEnhancement;
    useProgressiveFeature: typeof useProgressiveFeature;
    useCapability: typeof useCapability;
    useCapabilities: typeof useCapabilities;
    useCapabilityConditional: typeof useCapabilityConditional;
    CapabilityGate: typeof CapabilityGate;
    FeatureGate: typeof FeatureGate;
    createFeature: typeof createFeatureUtil;
    checkWebPSupport: typeof checkWebPSupport;
    checkAVIFSupport: typeof checkAVIFSupport;
};
export default _default;