import { default as React, ReactNode } from 'react';
/**
 * Flag exposure event
 */
export interface FlagExposureEvent {
    /** Feature flag key */
    readonly flagKey: string;
    /** Variant shown */
    readonly variant: string;
    /** User identifier */
    readonly userId?: string;
    /** Session identifier */
    readonly sessionId?: string;
    /** Page/route where exposed */
    readonly page?: string;
    /** Component that rendered the flag */
    readonly component?: string;
    /** Timestamp of exposure */
    readonly timestamp: number;
    /** Additional context */
    readonly context?: Readonly<Record<string, unknown>>;
}
/**
 * Flag evaluation event
 */
export interface FlagEvaluationEvent {
    /** Feature flag key */
    readonly flagKey: string;
    /** Evaluated value */
    readonly value: boolean | string | number;
    /** Reason for the value */
    readonly reason: 'flag' | 'override' | 'default' | 'error';
    /** Evaluation duration (ms) */
    readonly durationMs?: number;
    /** User identifier */
    readonly userId?: string;
    /** Timestamp of evaluation */
    readonly timestamp: number;
    /** Additional context */
    readonly context?: Readonly<Record<string, unknown>>;
}
/**
 * Performance metric with flag correlation
 */
export interface CorrelatedMetric {
    /** Metric name */
    readonly metricName: string;
    /** Metric value */
    readonly value: number;
    /** Unit of measurement */
    readonly unit?: string;
    /** Active flag states at time of measurement */
    readonly flagStates: Readonly<Record<string, boolean>>;
    /** Page/route where measured */
    readonly page?: string;
    /** User identifier */
    readonly userId?: string;
    /** Timestamp of measurement */
    readonly timestamp: number;
    /** Additional context */
    readonly context?: Readonly<Record<string, unknown>>;
}
/**
 * Error event with flag context
 */
export interface CorrelatedError {
    /** Error message */
    readonly message: string;
    /** Error stack trace */
    readonly stack?: string;
    /** Error type/name */
    readonly type: string;
    /** Active flag states when error occurred */
    readonly flagStates: Readonly<Record<string, boolean>>;
    /** Component where error occurred */
    readonly component?: string;
    /** Page/route where error occurred */
    readonly page?: string;
    /** Timestamp of error */
    readonly timestamp: number;
    /** Additional context */
    readonly context?: Readonly<Record<string, unknown>>;
}
/**
 * Feature impact metric
 */
export interface FeatureImpactMetric {
    /** Feature flag key */
    readonly flagKey: string;
    /** Metric name */
    readonly metricName: string;
    /** Value when flag is enabled */
    readonly enabledValue: number;
    /** Value when flag is disabled */
    readonly disabledValue: number;
    /** Percentage change */
    readonly percentageChange: number;
    /** Sample size for enabled variant */
    readonly enabledSampleSize: number;
    /** Sample size for disabled variant */
    readonly disabledSampleSize: number;
    /** Statistical significance (p-value) */
    readonly pValue?: number;
    /** Confidence interval */
    readonly confidenceInterval?: {
        lower: number;
        upper: number;
    };
    /** Time period of analysis */
    readonly period: {
        start: number;
        end: number;
    };
}
/**
 * Analytics destinations
 */
export interface AnalyticsDestination {
    /** Destination identifier */
    readonly id: string;
    /** Whether destination is enabled */
    readonly enabled: boolean;
    /** Send exposure event */
    sendExposure?(event: FlagExposureEvent): void | Promise<void>;
    /** Send evaluation event */
    sendEvaluation?(event: FlagEvaluationEvent): void | Promise<void>;
    /** Send correlated metric */
    sendMetric?(metric: CorrelatedMetric): void | Promise<void>;
    /** Send correlated error */
    sendError?(error: CorrelatedError): void | Promise<void>;
    /** Batch send events */
    flush?(): void | Promise<void>;
}
/**
 * Bridge configuration
 */
export interface FlagAnalyticsBridgeConfig {
    /** Destinations for analytics */
    readonly destinations?: readonly AnalyticsDestination[];
    /** Callback for exposure events */
    readonly onExposure?: (event: FlagExposureEvent) => void;
    /** Callback for evaluation events */
    readonly onEvaluation?: (event: FlagEvaluationEvent) => void;
    /** Callback for correlated metrics */
    readonly onMetric?: (metric: CorrelatedMetric) => void;
    /** Callback for correlated errors */
    readonly onError?: (error: CorrelatedError) => void;
    /** Callback for impact metrics */
    readonly onImpact?: (metric: FeatureImpactMetric) => void;
    /** Enable batching of events */
    readonly batchEnabled?: boolean;
    /** Batch size before flushing */
    readonly batchSize?: number;
    /** Batch flush interval (ms) */
    readonly batchInterval?: number;
    /** Sample rate for events (0-1) */
    readonly sampleRate?: number;
    /** Debug mode */
    readonly debug?: boolean;
    /** Get current user ID */
    readonly getUserId?: () => string | undefined;
    /** Get current session ID */
    readonly getSessionId?: () => string | undefined;
    /** Get current page/route */
    readonly getPage?: () => string | undefined;
    /** Get current flags */
    readonly getFlags?: () => Record<string, boolean>;
}
/**
 * Bridge interface
 */
export interface FlagAnalyticsBridge {
    /** Track flag exposure */
    trackExposure(event: Omit<FlagExposureEvent, 'timestamp'>): void;
    /** Track flag evaluation */
    trackEvaluation(event: Omit<FlagEvaluationEvent, 'timestamp'>): void;
    /** Track correlated performance metric */
    trackPerformanceCorrelation(metric: Omit<CorrelatedMetric, 'timestamp' | 'flagStates'>): void;
    /** Track correlated error */
    trackCorrelatedError(error: Omit<CorrelatedError, 'timestamp' | 'flagStates'>): void;
    /** Record impact metric */
    recordImpactMetric(metric: FeatureImpactMetric): void;
    /** Add analytics destination */
    addDestination(destination: AnalyticsDestination): void;
    /** Remove analytics destination */
    removeDestination(destinationId: string): void;
    /** Flush pending events */
    flush(): Promise<void>;
    /** Get exposure count for a flag */
    getExposureCount(flagKey: string): number;
    /** Get evaluation count for a flag */
    getEvaluationCount(flagKey: string): number;
    /** Get all tracked metrics */
    getMetrics(): CorrelatedMetric[];
    /** Get impact summary for a flag */
    getImpactSummary(flagKey: string): FeatureImpactMetric[];
    /** Reset all tracking data */
    reset(): void;
    /** Enable/disable the bridge */
    setEnabled(enabled: boolean): void;
    /** Check if bridge is enabled */
    isEnabled(): boolean;
}
/**
 * Create an analytics bridge
 */
export declare function createAnalyticsBridge(config?: FlagAnalyticsBridgeConfig): FlagAnalyticsBridge;
/**
 * Get the global analytics bridge
 */
export declare function getAnalyticsBridge(): FlagAnalyticsBridge;
/**
 * Initialize the global analytics bridge
 */
export declare function initAnalyticsBridge(config: FlagAnalyticsBridgeConfig): FlagAnalyticsBridge;
/**
 * Reset the global analytics bridge
 */
export declare function resetAnalyticsBridge(): void;
/**
 * Context value for flag analytics
 */
export interface FlagAnalyticsContextValue {
    /** Track exposure */
    trackExposure(flagKey: string, variant: string, context?: Record<string, unknown>): void;
    /** Track evaluation */
    trackEvaluation(flagKey: string, value: boolean | string | number, reason: 'flag' | 'override' | 'default' | 'error'): void;
    /** Track performance metric */
    trackMetric(metricName: string, value: number, unit?: string): void;
    /** Track error */
    trackError(error: Error, component?: string): void;
    /** Get exposure count */
    getExposureCount(flagKey: string): number;
    /** Flush analytics */
    flush(): Promise<void>;
}
/**
 * Props for FlagAnalyticsProvider
 */
export interface FlagAnalyticsProviderProps {
    readonly children: ReactNode;
    /** Analytics bridge instance */
    readonly bridge?: FlagAnalyticsBridge;
    /** Bridge configuration */
    readonly config?: FlagAnalyticsBridgeConfig;
    /** Get current flags */
    readonly getFlags?: () => Record<string, boolean>;
}
/**
 * Provider component for flag analytics
 */
export declare function FlagAnalyticsProvider({ children, bridge: providedBridge, config, getFlags, }: FlagAnalyticsProviderProps): React.JSX.Element;
/**
 * Hook to access flag analytics
 */
export declare function useFlagAnalytics(): FlagAnalyticsContextValue;
/**
 * Hook to automatically track exposure when a flag is used
 */
export declare function useTrackedFeatureFlag(flagKey: string, isEnabled: boolean, options?: {
    trackOnMount?: boolean;
    trackOnChange?: boolean;
    context?: Record<string, unknown>;
}): void;
/**
 * Create a console analytics destination (for debugging)
 */
export declare function createConsoleDestination(prefix?: string): AnalyticsDestination;
/**
 * Create a localStorage analytics destination (for offline storage)
 */
export declare function createLocalStorageDestination(key?: string): AnalyticsDestination;
/**
 * Create an HTTP endpoint analytics destination
 *
 * Note: This function intentionally uses raw fetch() rather than apiClient because:
 * 1. Analytics destinations should be independent of the main API client
 * 2. Analytics endpoints may be third-party services on different domains
 * 3. Avoids circular dependencies between analytics and API layers
 *
 * @see {@link @/lib/api/api-client} for application API calls
 */
export declare function createHttpDestination(config: {
    endpoint: string;
    method?: 'POST' | 'PUT';
    headers?: Record<string, string>;
    batchEvents?: boolean;
}): AnalyticsDestination;