import { FeatureFlag, WorkspaceFeatureFlag, CreateFlagData, UpdateFlagData, FeatureFlagStats, FeatureFlagsConfig, FlagValue, EvaluationContext, FeatureFlyEvent, EventHandler } from './types';
import type { MetricsSnapshot } from './metrics';
export declare class FetchError extends Error {
    response?: {
        status: number;
        data?: unknown;
    };
    constructor(message: string, status?: number, data?: unknown);
}
/**
 * FeatureFly SDK Client
 *
 * Framework-agnostic feature flags client with:
 * - In-memory caching with TTL
 * - Retry with exponential backoff + jitter
 * - Circuit breaker for resilience
 * - Typed event system
 * - Local overrides for dev/testing
 * - Fallback defaults for graceful degradation
 * - Multi-type flag values (boolean, string, number, JSON)
 *
 * @example
 * ```ts
 * const client = new FeatureFlagsClient({
 *   baseUrl: 'https://api.example.com',
 *   apiKey: 'your-key',
 * });
 *
 * const isEnabled = await client.evaluateFlag('new-feature', false, { workspaceId: '123' });
 * ```
 */
export declare class FeatureFlagsClient {
    private readonly baseUrl;
    private readonly timeout;
    private readonly headers;
    private readonly requestInterceptor?;
    private readonly withCredentials;
    private readonly cache;
    private readonly circuitBreaker;
    private readonly events;
    private readonly logger;
    private readonly retryConfig;
    private readonly localOverrides;
    private readonly fallbackDefaults;
    private readonly previousValues;
    private streamClient?;
    private edgeEvaluator?;
    private metrics?;
    private disposed;
    constructor(config: FeatureFlagsConfig);
    private readonly safeApiKey;
    private readonly streamingConfig;
    private edgeDocumentConfig;
    private readonly trackingCallbackConfig;
    private readonly metricsConfig;
    private metricsInitialized;
    private getEdgeEvaluator;
    private getMetrics;
    private ensureStreaming;
    private request;
    /**
     * Start or resume the SSE streaming connection.
     */
    startStreaming(): void;
    /**
     * Stop the SSE streaming connection.
     */
    stopStreaming(): void;
    /**
     * Fetch a full FlagDocument from the API to initialize Edge Evaluation mode.
     * If streaming is enabled, updates will auto-refresh the document.
     */
    loadEdgeDocument(): Promise<void>;
    private refreshEdgeDocument;
    /**
     * Subscribe to SDK events.
     * @returns Unsubscribe function
     */
    on<E extends FeatureFlyEvent>(event: E, handler: EventHandler<E>): () => void;
    /**
     * Subscribe to an event once.
     */
    once<E extends FeatureFlyEvent>(event: E, handler: EventHandler<E>): () => void;
    /**
     * Synchronously read a cached flag value without triggering evaluation.
     * Returns `undefined` if the flag is not in cache.
     * Useful for React/Vue hooks to avoid loading states when `bootstrapFlags` was provided.
     */
    getCachedFlag<T extends FlagValue>(slug: string, context?: EvaluationContext): T | undefined;
    /**
     * Synchronously read all cached batch-evaluated flags.
     * Returns `undefined` if no batch evaluation has been cached.
     */
    getCachedFlags(context?: EvaluationContext): Record<string, FlagValue> | undefined;
    /**
     * Evaluate a single flag. Returns the flag value.
     *
     * Resolution order:
     * 1. Local overrides (dev/testing)
     * 2. Edge evaluation (if edgeDocument configured)
     * 3. Cache hit
     * 4. Remote API call
     * 5. Fallback defaults
     */
    evaluateFlag<T extends FlagValue>(slug: string, defaultValue: T, context?: EvaluationContext): Promise<T>;
    /**
     * Evaluate all flags in a single batch request.
     */
    evaluateAllFlags(context?: EvaluationContext): Promise<Record<string, FlagValue>>;
    createFlag(data: CreateFlagData): Promise<FeatureFlag>;
    getAllFlags(): Promise<FeatureFlag[]>;
    getFlagById(id: string): Promise<FeatureFlag | null>;
    getFlagBySlug(slug: string): Promise<FeatureFlag | null>;
    updateFlag(id: string, data: UpdateFlagData): Promise<FeatureFlag>;
    deleteFlag(id: string): Promise<void>;
    setWorkspaceFlag(slug: string, workspaceId: string, value: FlagValue): Promise<WorkspaceFeatureFlag>;
    removeWorkspaceFlag(slug: string, workspaceId: string): Promise<void>;
    getWorkspaceFlags(workspaceId: string): Promise<WorkspaceFeatureFlag[]>;
    getFlagStats(): Promise<FeatureFlagStats>;
    getFlagsByCategory(category: 'frontend' | 'backend' | 'both'): Promise<FeatureFlag[]>;
    getFlagsByTargetService(serviceName: string): Promise<FeatureFlag[]>;
    /**
     * Set a local override for a flag. Overrides skip HTTP entirely.
     * Useful for development and testing.
     */
    setLocalOverride(slug: string, value: FlagValue): void;
    /**
     * Remove a local override.
     */
    removeLocalOverride(slug: string): void;
    /**
     * Get all local overrides.
     */
    getLocalOverrides(): Record<string, FlagValue>;
    /**
     * Clear all local overrides.
     */
    clearLocalOverrides(): void;
    /**
     * Clear all cached data.
     */
    clearCache(): void;
    /**
     * Get cache statistics.
     */
    getCacheStats(): {
        size: number;
        keys: string[];
        enabled: boolean;
    };
    /**
     * Get current circuit breaker state.
     */
    getCircuitBreakerState(): {
        state: string;
        failures: number;
    };
    /**
     * Reset the circuit breaker to closed state.
     */
    resetCircuitBreaker(): void;
    /**
     * Check if the client has been disposed.
     */
    isDisposed(): boolean;
    /**
     * Get a snapshot of all collected impact metrics.
     * Includes per-flag evaluation counts, cache hit rates, latency percentiles,
     * and experiment exposure counts.
     */
    getImpactMetrics(): Promise<MetricsSnapshot | null>;
    /**
     * Reset all collected impact metrics counters.
     */
    resetMetrics(): Promise<void>;
    /**
     * Dispose the client, releasing all resources (timers, listeners, metrics).
     * After calling dispose, the client cannot be used again.
     */
    dispose(): void;
    private fetchWithResiliency;
    private buildCacheKey;
    private detectChange;
    private emitEvaluated;
    private assertNotDisposed;
}