import type { DataFile, HumanReadableId as DataFileHumanReadableId, RolloutPercent as DataFileRolloutPercent, Uuid } from './data-file';
import { TargetOperator as DataFileTargetOperator, TargetType as DataFileTargetType } from './data-file';
import type { Logger } from './logger';
export declare type Variable = unknown;
export declare type HumanReadableId = DataFileHumanReadableId;
export declare type RolloutPercent = DataFileRolloutPercent;
export declare const TargetOperator: typeof DataFileTargetOperator;
export declare type TargetOperator = DataFileTargetOperator;
export declare const TargetType: typeof DataFileTargetType;
export declare type TargetType = DataFileTargetType;
export declare type Target = {
    key: string;
    match: (value: unknown) => boolean;
    operator: TargetOperator;
    type: TargetType;
    uuid: Uuid;
};
export interface EnabledFeature {
    enabled: true;
    humanReadableId: HumanReadableId;
    targetingCount: number;
    targeting: {
        [name: string]: Target;
    };
    uuid: Uuid;
    variables: {
        [name: string]: Variable;
    };
}
export interface DisabledFeature {
    enabled: false;
    humanReadableId: HumanReadableId;
    targetingCount: 0;
    targeting?: undefined;
    uuid: Uuid;
    variables?: undefined;
}
export declare type Feature = EnabledFeature | DisabledFeature;
export interface Variant {
    feature: Feature;
    humanReadableId: HumanReadableId;
    rolloutPercent: RolloutPercent;
    uuid: Uuid;
}
export interface EnabledExperiment {
    enabled: true;
    humanReadableId: HumanReadableId;
    rolloutPercent: RolloutPercent;
    targeting: {
        [name: string]: Target;
    };
    targetingCount: number;
    uuid: Uuid;
    variants: Array<Variant>;
}
export interface DisabledExperiment {
    enabled: false;
    humanReadableId: HumanReadableId;
    rolloutPercent: 0;
    targeting?: undefined;
    targetingCount: 0;
    uuid: Uuid;
    variants?: undefined;
}
export declare type Experiment = EnabledExperiment | DisabledExperiment;
export declare type Targeting = Record<string, unknown>;
export interface FormattedData {
    experiments: Array<[HumanReadableId, Array<Experiment>]>;
    features: Array<[HumanReadableId, Array<Feature>]>;
}
export interface TargetedData {
    features: Map<HumanReadableId, Feature>;
    experiments: Map<HumanReadableId, Experiment>;
}
export interface ExperimentData {
    experiment: Experiment | undefined;
    experimentFeatures: Set<string>;
    isDecisionMade: boolean;
    variant: Variant | undefined;
}
export interface Store {
    getActiveExperiment: () => Experiment | undefined;
    getActiveVariant: () => Variant | undefined;
    getDataFile: () => DataFile | undefined;
    getDeviceId: () => string | undefined;
    getFeature: (humanReadableId: string) => Feature | undefined;
    getRevision: () => string | undefined;
    getTargeting: () => Targeting | undefined;
    isDataFileAvailable: () => boolean;
    isDecisionMade: () => boolean;
    isDeviceIdentified: () => boolean;
    isFeatureVariant: (humanReadableId: string) => boolean;
    registerDecision: () => void;
    setDataFile: (dataFile: DataFile) => void;
    setDeviceId: (deviceId: string) => void;
    setTargeting: (targeting: Targeting) => void;
}
export declare const create: (dataFile: DataFile | undefined, deviceId: string | undefined, targeting: Targeting | undefined, logger: Logger) => Store;
export declare const targetUserExperience: (formattedData: FormattedData, targeting: Record<string, unknown> | undefined, logger: Logger) => TargetedData;
export declare const decideUserExperience: (experiments: TargetedData['experiments'], deviceId: string | undefined, logger: Logger) => ExperimentData;
//# sourceMappingURL=store.d.ts.map