import { ConfigCondition, ConfigRule, ConfigSpec } from './ConfigSpec';
import { HashingAlgorithm } from './utils/Hashing';
import { ClientInitializeResponseOptions } from './StatsigServer';
import ConfigEvaluation from './ConfigEvaluation';
import Diagnostics from './Diagnostics';
import { ExplicitStatsigOptions } from './StatsigOptions';
import { SecondaryExposure } from './LogEvent';
import StatsigFetcher from './utils/StatsigFetcher';
import { StatsigUser } from './StatsigUser';
type InitializeResponse = {
    name: string;
    value: unknown;
    group: string;
    rule_id: string;
    is_device_based: boolean;
    secondary_exposures: unknown;
    is_experiment_active?: boolean;
    is_user_in_experiment?: boolean;
    is_in_layer?: boolean;
    allocated_experiment_name?: string;
    explicit_parameters?: string[];
    undelegated_secondary_exposures?: Record<string, string>[];
    group_name?: string | null;
    id_type?: string | null;
    passed?: boolean;
};
export type ClientInitializeResponse = {
    feature_gates: Record<string, InitializeResponse>;
    dynamic_configs: Record<string, InitializeResponse>;
    layer_configs: Record<string, InitializeResponse>;
    sdkParams: Record<string, unknown>;
    has_updates: boolean;
    generator: 'statsig-node-lite-sdk';
    sdkInfo: {
        sdkType: string;
        sdkVersion: string;
    };
    time: number;
    evaluated_keys: Record<string, unknown>;
    hash_used: HashingAlgorithm;
    user: StatsigUser;
};
export default class Evaluator {
    private gateOverrides;
    private configOverrides;
    private layerOverrides;
    private initialized;
    private store;
    constructor(sdkKey: string, fetcher: StatsigFetcher, options: ExplicitStatsigOptions, diagnostics: Diagnostics);
    init(): Promise<void>;
    overrideGate(gateName: string, value: boolean, userID?: string | null): void;
    overrideConfig(configName: string, value: Record<string, unknown>, userID?: string | null): void;
    overrideLayer(layerName: string, value: Record<string, unknown>, userID?: string | null): void;
    checkGate(user: StatsigUser, gateName: string): ConfigEvaluation;
    getConfig(user: StatsigUser, configName: string): ConfigEvaluation;
    getLayer(user: StatsigUser, layerName: string): ConfigEvaluation;
    getClientInitializeResponse(user: StatsigUser, options?: ClientInitializeResponseOptions): ClientInitializeResponse | null;
    clearAllGateOverrides(): void;
    clearAllConfigOverrides(): void;
    clearAllLayerOverrides(): void;
    resetSyncTimerIfExited(): Error | null;
    syncBootstrapValues(bootstrapValues: string): void;
    syncStoreSpecs(): Promise<void>;
    syncStoreIdLists(): Promise<void>;
    getFeatureGateList(): string[];
    getConfigsList(entityType: 'experiment' | 'dynamic_config' | 'autotune'): string[];
    getLayerList(): string[];
    private lookupGateOverride;
    private lookupConfigOverride;
    private lookupLayerOverride;
    private lookupConfigBasedOverride;
    private _specToInitializeResponse;
    private _cleanExposures;
    shutdown(): void;
    _evalSpec(user: StatsigUser, config: ConfigSpec | null): ConfigEvaluation;
    _eval(user: StatsigUser, config: ConfigSpec): ConfigEvaluation;
    _evalDelegate(user: StatsigUser, rule: ConfigRule, exposures: SecondaryExposure[]): ConfigEvaluation | null;
    _evalPassPercent(user: StatsigUser, rule: ConfigRule, config: ConfigSpec): boolean;
    _getUnitID(user: StatsigUser, idType: string): unknown;
    _evalRule(user: StatsigUser, rule: ConfigRule): ConfigEvaluation;
    _evalCondition(user: StatsigUser, condition: ConfigCondition): {
        passes: boolean;
        unsupported?: boolean;
        exposures?: SecondaryExposure[];
    };
    _isExperimentActive(experimentConfig: ConfigSpec | null): boolean;
    _isUserAllocatedToExperiment(user: StatsigUser, experimentConfig: ConfigSpec | null): boolean;
}
export declare function computeUserHash(userHash: string): bigint;
export declare function dateCompare(fn: (a: Date, b: Date) => boolean): (a: string | number, b: string | number) => boolean;
export {};