import { EvaluationResultWithMetadata } from '../flagsmith-engine/evaluation/models.js';
import { FeatureStateModel } from '../flagsmith-engine/features/models.js';
import { AnalyticsProcessor } from './analytics.js';
type FlagValue = string | number | boolean | undefined | null;
/**
 * A Flagsmith feature. It has an enabled/disabled state, and an optional {@link FlagValue}.
 */
export declare class BaseFlag {
    /**
     * Indicates whether this feature is enabled.
     */
    enabled: boolean;
    /**
     * An optional {@link FlagValue} for this feature.
     */
    value: FlagValue;
    /**
     * If true, the state for this feature was determined by a default flag handler. See {@link DefaultFlag}.
     */
    isDefault: boolean;
    constructor(value: FlagValue, enabled: boolean, isDefault: boolean);
}
/**
 * A {@link BaseFlag} returned by a default flag handler when flag evaluation fails.
 * @see FlagsmithConfig#defaultFlagHandler
 */
export declare class DefaultFlag extends BaseFlag {
    constructor(value: FlagValue, enabled: boolean);
}
/**
 * A running experiment on a feature, as reported by an identity evaluation.
 */
export declare class ExperimentMetadata {
    /**
     * An identifier for this experiment, unique in a single Flagsmith installation.
     */
    id: number;
    /**
     * The name of this experiment, as shown in the Flagsmith dashboard.
     */
    name: string;
    /**
     * Whether this identity is enrolled in the experiment. A {@link Flag.variant} alone cannot tell:
     * an identity outside the experiment's rollout is still bucketed into a variant.
     */
    inExperiment: boolean;
    constructor(params: {
        id: number;
        name: string;
        inExperiment: boolean;
    });
    /**
     * Build an {@link ExperimentMetadata} from the `metadata` object of an API flag.
     *
     * @param metadata The `metadata` value of an API flag. Keys other than `experiment` are ignored.
     * @returns `undefined` if no usable experiment is present.
     */
    static fromAPIMetadata(metadata: unknown): ExperimentMetadata | undefined;
}
/**
 * A Flagsmith feature retrieved from a successful flag evaluation.
 */
export declare class Flag extends BaseFlag {
    /**
     * An identifier for this feature, unique in a single Flagsmith installation.
     */
    featureId: number;
    /**
     * The programmatic name for this feature, unique per Flagsmith project.
     */
    featureName: string;
    /**
     * The reason for this feature, unique per Flagsmith project.
     */
    reason?: string;
    /**
     * The variant key this identity was bucketed into. Set by identity evaluation only.
     */
    variant?: string;
    /**
     * The experiment running on this feature, if any. Set by identity evaluation only.
     */
    experiment?: ExperimentMetadata;
    constructor(params: {
        value: FlagValue;
        enabled: boolean;
        isDefault?: boolean;
        featureId: number;
        featureName: string;
        reason?: string;
        variant?: string;
        experiment?: ExperimentMetadata;
    });
    static fromFeatureStateModel(fsm: FeatureStateModel, identityId: number | string | undefined): Flag;
    static fromAPIFlag(flagData: any): Flag;
}
export declare class Flags {
    flags: {
        [key: string]: Flag;
    };
    defaultFlagHandler?: (featureName: string) => DefaultFlag;
    analyticsProcessor?: AnalyticsProcessor;
    constructor(data: {
        flags: {
            [key: string]: Flag;
        };
        defaultFlagHandler?: (v: string) => DefaultFlag;
        analyticsProcessor?: AnalyticsProcessor;
    });
    static fromEvaluationResult(evaluationResult: EvaluationResultWithMetadata, defaultFlagHandler?: (v: string) => DefaultFlag, analyticsProcessor?: AnalyticsProcessor): Flags;
    static fromFeatureStateModels(data: {
        featureStates: FeatureStateModel[];
        analyticsProcessor?: AnalyticsProcessor;
        defaultFlagHandler?: (f: string) => DefaultFlag;
        identityID?: string | number;
    }): Flags;
    static fromAPIFlags(data: {
        apiFlags: {
            [key: string]: any;
        }[];
        analyticsProcessor?: AnalyticsProcessor;
        defaultFlagHandler?: (v: string) => DefaultFlag;
    }): Flags;
    allFlags(): Flag[];
    getFlag(featureName: string): BaseFlag;
    getFeatureValue(featureName: string): FlagValue;
    isFeatureEnabled(featureName: string): boolean;
}
export {};