import { FeatureFlag, FlagId, EvaluationContext, EvaluationResult, Segment, FlagEngineConfig, JsonValue } from './types';
/**
 * Core feature flag evaluation engine.
 *
 * Provides comprehensive flag evaluation with support for targeting rules,
 * percentage rollouts, segments, and dependencies.
 */
export declare class FlagEngine {
    private flags;
    private segments;
    private context;
    private cache;
    private config;
    private targetingEngine;
    private rolloutEngine;
    private segmentMatcher;
    private dependencyResolver;
    private readonly hashFunction;
    private previousValues;
    private initialized;
    constructor(config?: FlagEngineConfig);
    /**
     * Set the evaluation context.
     */
    setContext(context: EvaluationContext): void;
    /**
     * Update specific context properties.
     */
    updateContext(updates: Partial<EvaluationContext>): void;
    /**
     * Get the current context.
     */
    getContext(): EvaluationContext;
    /**
     * Register feature flags.
     */
    registerFlags(flags: readonly FeatureFlag[]): void;
    /**
     * Register a single flag.
     */
    registerFlag(flag: FeatureFlag): void;
    /**
     * Remove a flag.
     */
    removeFlag(flagId: FlagId): void;
    /**
     * Register segments.
     */
    registerSegments(segments: readonly Segment[]): void;
    /**
     * Get a flag by key.
     */
    getFlag(key: string): FeatureFlag | undefined;
    /**
     * Get all registered flags.
     */
    getAllFlags(): FeatureFlag[];
    /**
     * Evaluate a feature flag.
     */
    evaluate<T = JsonValue>(flagKey: string, contextOverrides?: Partial<EvaluationContext>): EvaluationResult<T>;
    /**
     * Evaluate a boolean flag (convenience method).
     */
    isEnabled(flagKey: string, contextOverrides?: Partial<EvaluationContext>): boolean;
    /**
     * Evaluate a string flag.
     */
    getStringValue(flagKey: string, _defaultValue: string, contextOverrides?: Partial<EvaluationContext>): string;
    /**
     * Evaluate a number flag.
     */
    getNumberValue(flagKey: string, _defaultValue: number, contextOverrides?: Partial<EvaluationContext>): number;
    /**
     * Evaluate a JSON flag.
     */
    getJsonValue<T extends JsonValue>(flagKey: string, defaultValue: T, contextOverrides?: Partial<EvaluationContext>): T;
    /**
     * Evaluate multiple flags at once.
     */
    evaluateAll(flagKeys: readonly string[], contextOverrides?: Partial<EvaluationContext>): Map<string, EvaluationResult>;
    /**
     * Get all enabled flags.
     */
    getEnabledFlags(contextOverrides?: Partial<EvaluationContext>): Map<string, EvaluationResult>;
    /**
     * Track an exposure event (for experiments).
     */
    trackExposure(flagKey: string, experimentId?: string, metadata?: Record<string, JsonValue>): void;
    /**
     * Invalidate cache for a flag.
     */
    invalidateCache(flagKey: string): void;
    /**
     * Clear all cached evaluations.
     */
    clearCache(): void;
    /**
     * Get cache statistics.
     */
    getCacheStats(): {
        size: number;
        keys: string[];
    };
    /**
     * Check if the engine is initialized.
     */
    isInitialized(): boolean;
    /**
     * Get engine statistics.
     */
    getStats(): {
        flagCount: number;
        segmentCount: number;
        cacheSize: number;
        initialized: boolean;
    };
    /**
     * Reset the engine to initial state.
     */
    reset(): void;
    private evaluateInternal;
    private checkDependencies;
    private checkSegments;
    private createResult;
    private createDefaultResult;
    private createErrorResult;
    private trackEvaluation;
    private checkForChanges;
    private log;
}
/**
 * Get the singleton flag engine instance.
 */
export declare function getFlagEngine(): FlagEngine;
/**
 * Initialize the flag engine with configuration.
 */
export declare function initFlagEngine(config: FlagEngineConfig): FlagEngine;
/**
 * Reset the singleton instance.
 */
export declare function resetFlagEngine(): void;