import type { PrerequisiteFlagComparator, SegmentComparator, UserComparator } from "./ConfigJson.js";
import { SettingType } from "./ConfigJson.js";
import * as ConfigJson from "./ConfigJson.js";
import type { ObjectMap } from "./Utils.js";
export { ConfigJson };
export declare class ProjectConfig {
    readonly configJson: string | undefined;
    readonly config: Config | undefined;
    readonly timestamp: number;
    readonly httpETag: string | undefined;
    static readonly serializationFormatVersion = "v2";
    static readonly empty: ProjectConfig;
    static contentEquals(projectConfig1: ProjectConfig, projectConfig2: ProjectConfig): boolean;
    constructor(configJson: string | undefined, config: Config | undefined, timestamp: number, httpETag: string | undefined);
    with(timestamp: number): ProjectConfig;
    get isEmpty(): boolean;
    isExpired(expirationMs: number): boolean;
    static generateTimestamp(): number;
    static serialize(config: ProjectConfig): string;
    static deserialize(value: string): ProjectConfig;
}
export declare function getTimestampAsDate(projectConfig: ProjectConfig | null): Date | undefined;
export type UnknownSettingType = -1;
/** @remarks May or may not be a null-prototype object. */
export type SettingMap = Readonly<Record<string, Setting> | ObjectMap<string, Setting>>;
export type SettingValue = boolean | string | number | null | undefined;
export type VariationIdValue = string | null | undefined;
type AdjustedConfigJsonConfig = PartialWithNull<ChangePropType<ConfigJson.Config, {
    "p": PartialWithNull<ConfigJson.Preferences>;
    "s": AdjustedConfigJsonSegment[];
    "f": {
        [key: string]: AdjustedConfigJsonSetting;
    };
}>>;
/** Describes a ConfigCat config's data model used for feature flag evaluation. */
export declare abstract class Config implements Immutable<AdjustedConfigJsonConfig> {
    private readonly _guard;
    readonly p?: Immutable<PartialWithNull<ConfigJson.Preferences>> | null;
    readonly s?: ReadonlyArray<Segment> | null;
    readonly f?: Readonly<Record<string, Setting>> | null;
}
type AdjustedConfigJsonSegment = OptionalWithNull<ChangePropType<ConfigJson.Segment, {
    "r": AdjustedConfigJsonUserCondition[];
}>, "r">;
/** Describes a segment. */
export declare abstract class Segment implements Immutable<AdjustedConfigJsonSegment> {
    readonly n: string;
    readonly r?: ReadonlyArray<UserCondition> | null;
}
type FlattenedConfigJsonSettingValue = PartialWithNull<UnionToIntersection<OmitNeverProps<ConfigJson.SettingValue>>>;
/** Contains a value of one of the possible types. */
export declare abstract class SettingValueModel implements Immutable<FlattenedConfigJsonSettingValue> {
    readonly b?: boolean | null;
    readonly s?: string | null;
    readonly i?: number | null;
    readonly d?: number | null;
}
type AdjustedConfigJsonServedValue = OptionalWithNull<ChangePropType<ConfigJson.ServedValue, {
    "v": FlattenedConfigJsonSettingValue | NonNullable<SettingValue>;
}>, "i">;
/** Contains a setting value along with related data. */
export declare abstract class SettingValueContainer<TValue extends SettingValueModel | NonNullable<SettingValue> = SettingValueModel> implements Immutable<AdjustedConfigJsonServedValue> {
    readonly v: TValue;
    /** @remarks May be missing in the case of flag overrides. */
    readonly i?: string | null;
}
type AdjustedConfigJsonSetting = OptionalWithNull<ChangePropType<ConfigJson.Setting, {
    "t": SettingType | UnknownSettingType;
    "r": AdjustedConfigJsonTargetingRule[];
    "p": AdjustedConfigJsonPercentageOption[];
    "v": FlattenedConfigJsonSettingValue | NonNullable<SettingValue>;
}>, "i" | "a" | "r" | "p">;
/** Describes a feature flag or setting. */
export declare abstract class Setting extends SettingValueContainer<SettingValueModel | NonNullable<SettingValue>> implements Immutable<AdjustedConfigJsonSetting> {
    /** @remarks Can also be `-1` when the setting comes from a simple flag override. */
    readonly t: SettingType | UnknownSettingType;
    readonly a?: string | null;
    readonly r?: ReadonlyArray<TargetingRule> | null;
    readonly p?: ReadonlyArray<PercentageOption> | null;
    /** @remarks Can be a plain `boolean`, `string` or `number` value in the case of a a simple flag override. */
    readonly v: SettingValueModel | NonNullable<SettingValue>;
    private ["_configJsonSalt"];
    private ["_configSegments"];
}
type AdjustedConfigJsonTargetingRule = OptionalWithNull<ChangePropType<UnionToIntersection<OmitNeverProps<ConfigJson.TargetingRule>>, {
    "c": FlattenedConfigJsonCondition[];
    "s": AdjustedConfigJsonServedValue;
    "p": AdjustedConfigJsonPercentageOption[];
}>, "c" | "s" | "p">;
/** Describes a targeting rule. */
export declare abstract class TargetingRule implements Immutable<AdjustedConfigJsonTargetingRule> {
    readonly c?: ReadonlyArray<ConditionContainer> | null;
    readonly s?: SettingValueContainer | null;
    readonly p?: ReadonlyArray<PercentageOption> | null;
}
type AdjustedConfigJsonPercentageOption = OptionalWithNull<ChangePropType<ConfigJson.ServedValue, {
    "v": FlattenedConfigJsonSettingValue;
}>, "i">;
/** Describes a percentage option. */
export declare abstract class PercentageOption extends SettingValueContainer implements Immutable<AdjustedConfigJsonPercentageOption> {
    readonly p: number;
}
type FlattenedConfigJsonCondition = PartialWithNull<ChangePropType<UnionToIntersection<OmitNeverProps<ConfigJson.ConditionUnion>>, {
    "u": AdjustedConfigJsonUserCondition;
    "p": AdjustedConfigJsonPrerequisiteFlagCondition;
}>>;
/** Contains one of the possible conditions. */
export declare abstract class ConditionContainer implements Immutable<FlattenedConfigJsonCondition> {
    readonly u?: UserCondition | null;
    readonly p?: PrerequisiteFlagCondition | null;
    readonly s?: SegmentCondition | null;
}
export type Condition = UserCondition | PrerequisiteFlagCondition | SegmentCondition;
type AdjustedConfigJsonUserCondition = OptionalWithNull<UnionToIntersection<OmitNeverProps<ConfigJson.UserCondition>>, "s" | "d" | "l">;
/** Describes a condition that is based on a User Object attribute. */
export declare abstract class UserCondition implements Immutable<AdjustedConfigJsonUserCondition> {
    readonly a: string;
    readonly c: UserComparator;
    readonly s?: string | null;
    readonly d?: number | null;
    readonly l?: ReadonlyArray<string> | null;
}
type AdjustedConfigJsonPrerequisiteFlagCondition = ChangePropType<ConfigJson.PrerequisiteFlagCondition, {
    "v": FlattenedConfigJsonSettingValue;
}>;
/** Describes a condition that is based on a prerequisite flag. */
export declare abstract class PrerequisiteFlagCondition implements Immutable<AdjustedConfigJsonPrerequisiteFlagCondition> {
    readonly f: string;
    readonly c: PrerequisiteFlagComparator;
    readonly v: SettingValueModel;
}
/** Describes a condition that is based on a segment. */
export declare abstract class SegmentCondition implements Immutable<ConfigJson.SegmentCondition> {
    readonly s: number;
    readonly c: SegmentComparator;
}
/**
 * Deserializes the specified config JSON to a `Config` model that can be used for feature flag evaluation.
 *
 * @remarks Does superficial model validation only, meaning that the method makes sure that the specified config JSON
 * matches the type definition of the `Config` model, but doesn't check for semantic issues. E.g. doesn't validate
 * whether referenced segments and feature flags actually exist. (Such issues are checked during feature flag evaluation.)
 */
export declare function deserializeConfig(configJson: string): Config;
/**
 * Prepares the specified preparsed config JSON so it can be used for feature flag evaluation. Makes direct
 * modifications to the specified object and returns the same reference cast as type `Config`.
 *
 * @remarks Does superficial model validation only, meaning that the method makes sure that the specified config JSON
 * matches the type definition of the `Config` model, but doesn't check for semantic issues. E.g. doesn't validate
 * whether referenced segments and feature flags actually exist. (Such issues are checked during feature flag evaluation.)
 */
export declare function prepareConfig(config: Partial<ConfigJson.Config>): Config;
/**
 * Creates a setting that can be used for feature flag evaluation from the specified value.
 */
export declare function createSettingFromValue(value: NonNullable<SettingValue>): Setting;
export declare function nameOfSettingType(value: SettingType): string;
export declare function getSettingType(setting: Setting): SettingType | UnknownSettingType;
export declare function inferSettingType(value: unknown): SettingType | undefined;
export declare function isCompatibleValue(value: SettingValue, settingType: SettingType): boolean;
export declare function isAllowedValue(value: unknown): value is NonNullable<SettingValue>;
export declare function hasPercentageOptions(targetingRule: TargetingRule): boolean;
export declare function hasPercentageOptions(targetingRule: TargetingRule, ignoreIfInvalid: true): boolean | undefined;
export declare function getConditionType(container: ConditionContainer): keyof ConditionContainer;
export declare function unwrapValue(settingValue: SettingValueModel | NonNullable<SettingValue>, settingType: SettingType | UnknownSettingType | null, ignoreIfInvalid?: false): NonNullable<SettingValue>;
export declare function unwrapValue(settingValue: SettingValueModel | NonNullable<SettingValue>, settingType: SettingType | UnknownSettingType | null, ignoreIfInvalid: true): NonNullable<SettingValue> | undefined;
export declare function throwInvalidConfigModelError(message: string): never;
export declare class InvalidConfigModelError extends Error {
    readonly message: string;
    readonly name: string;
    constructor(message: string);
}
/** Recursively makes object `T` immutable by making arrays and object properties read-only. */
type Immutable<T> = {
    readonly [K in keyof T]: NonNullable<T[K]> extends ReadonlyArray<infer U> ? ReadonlyArray<Immutable<U>> | (T[K] & (null | undefined)) : NonNullable<T[K]> extends object ? Immutable<T[K]> : T[K];
};
/** Makes all properties optional in object `T` while also allowing `null`. */
type PartialWithNull<T> = {
    [P in keyof T]?: T[P] | null;
};
/** Makes properties specified by `K` optional in object `T` while also allowing `null`. */
type OptionalWithNull<T, K extends keyof T> = Pick<PartialWithNull<T>, K> & Omit<T, K>;
/** Changes the type of properties specified by `TPropMap` in object `T`. */
type ChangePropType<T, TPropMap extends {
    [K in keyof T]?: unknown;
}> = {
    [K in keyof T]: K extends keyof TPropMap ? TPropMap[K] : T[K];
};
/** Removes properties of type `never` from object `T`. */
type OmitNeverProps<T> = Pick<T, {
    [K in keyof T]: T[K] extends never ? never : K;
}[keyof T]>;
/** Converts union type `U` to an intersection type. */
type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;