import { EvaluationContextWithMetadata, EvaluationResultSegments, EvaluationResultWithMetadata, FeatureContextWithMetadata, SDKFeatureMetadata } from './evaluation/models.js';
import { EvaluationResultFlags } from './evaluation/models.js';
export { EnvironmentModel } from './environments/models.js';
export { IdentityModel } from './identities/models.js';
export { TraitModel } from './identities/traits/models.js';
export { SegmentModel } from './segments/models.js';
export { FeatureModel, FeatureStateModel } from './features/models.js';
export { OrganisationModel } from './organisations/models.js';
type SegmentOverride = {
    feature: FeatureContextWithMetadata;
    segmentName: string;
};
export type SegmentOverrides = Record<string, SegmentOverride>;
/**
 * Evaluates flags and segments for the given context.
 *
 * This is the main entry point for the evaluation engine. It processes segments,
 * applies feature overrides based on segment priority, and returns the final flag states with
 * evaluation reasons.
 *
 * @param context - EvaluationContext containing environment, identity, and segment data
 * @returns EvaluationResult with flags, segments, and original context
 */
export declare function getEvaluationResult(context: EvaluationContextWithMetadata): EvaluationResultWithMetadata;
/**
 * Resolves the flags that segment conditions read from `$.flags`, as they are first read.
 *
 * Flags supplied with the context are discarded: `$.flags` only ever holds flags resolved here.
 */
export declare class FlagDependencies {
    readonly context: EvaluationContextWithMetadata;
    readonly resolved: EvaluationResultFlags<SDKFeatureMetadata>;
    readonly cyclic: Set<string>;
    used: boolean;
    cycleHits: number;
    private readonly segments;
    private readonly resolving;
    private readonly segmentMatches;
    private segmentKeysByFeatureNameCache?;
    constructor(context: EvaluationContextWithMetadata);
    private get segmentKeysByFeatureName();
    private resolveFeature;
    private getSegmentOverride;
    private matchesSegment;
}
/**
 * Evaluates which segments the context belongs to and collects feature overrides.
 *
 * A segment whose evaluation cut a flag dependency cycle is left out, matched or not.
 *
 * @param context - EvaluationContext containing segment definitions
 * @param dependencies - Flag dependencies read by segment conditions, if any
 * @returns Object containing segments the context belongs to and any feature overrides
 */
export declare function evaluateSegments(context: EvaluationContextWithMetadata, dependencies?: FlagDependencies): {
    segments: EvaluationResultSegments;
    segmentOverrides: Record<string, SegmentOverride>;
};
/**
 * Processes feature overrides from segments, applying priority rules.
 *
 * When multiple segments override the same feature, the segment with
 * higher priority (lower numeric value) takes precedence.
 *
 * @param identitySegments - Segments that the identity belongs to
 * @returns Map of feature keys to their highest-priority segment overrides
 */
export declare function processSegmentOverrides(identitySegments: any[]): Record<string, SegmentOverride>;
/**
 * Evaluates all features in the context, applying segment overrides where applicable.
 * For each feature:
 * - Checks if a segment override exists
 * - Uses override values if present, otherwise evaluates the base feature
 * - Determines appropriate evaluation reason
 * - Handles multivariate evaluation for features without overrides
 *
 * @param context - EvaluationContext containing features and identity
 * @param segmentOverrides - Map of feature keys to their segment overrides
 * @returns EvaluationResultFlags containing evaluated flag results
 */
export declare function evaluateFeatures(context: EvaluationContextWithMetadata, segmentOverrides: Record<string, SegmentOverride>): EvaluationResultFlags<SDKFeatureMetadata>;
export declare function shouldApplyOverride(override: any, existingOverrides: Record<string, SegmentOverride>): boolean;
export declare function isHigherPriority(priorityA: number | undefined, priorityB: number | undefined): boolean;
export type TargetingMatchReason = {
    type: 'SEGMENT';
    override?: SegmentOverride;
    hasSegmentOverrides: boolean;
} | {
    type: 'SPLIT';
    weight: number;
};