import { Variant, VariantId, VariantValueType, JsonValue, VariantAllocation } from './types';
/**
 * Options for creating a variant.
 */
export interface CreateVariantOptions<T = JsonValue> {
    /** Variant value */
    readonly value: T;
    /** Human-readable name */
    readonly name?: string;
    /** Description */
    readonly description?: string;
    /** Whether this is the control variant */
    readonly isControl?: boolean;
    /** Additional payload data */
    readonly payload?: Record<string, JsonValue>;
    /** File/config attachments */
    readonly attachments?: string[];
}
/**
 * Variant with weight for traffic allocation.
 */
export interface WeightedVariant<T = JsonValue> extends Variant<T> {
    /** Weight for traffic allocation (0-100) */
    readonly weight: number;
}
/**
 * Variant statistics for experiments.
 */
export interface VariantStats {
    /** Variant ID */
    readonly variantId: VariantId;
    /** Number of users assigned */
    readonly userCount: number;
    /** Number of conversions */
    readonly conversions: number;
    /** Conversion rate */
    readonly conversionRate: number;
    /** Average value (for numeric metrics) */
    readonly averageValue?: number;
    /** Standard deviation */
    readonly standardDeviation?: number;
    /** Confidence interval */
    readonly confidenceInterval?: [number, number];
}
/**
 * Variant comparison result.
 */
export interface VariantComparison {
    /** Control variant stats */
    readonly control: VariantStats;
    /** Treatment variant stats */
    readonly treatment: VariantStats;
    /** Relative lift (treatment vs control) */
    readonly relativeLift: number;
    /** Statistical significance (p-value) */
    readonly pValue: number;
    /** Whether result is statistically significant */
    readonly isSignificant: boolean;
    /** Confidence level used */
    readonly confidenceLevel: number;
}
/**
 * Manager for creating and working with flag variants.
 */
export declare class VariantManager {
    /**
     * Create a new variant.
     */
    createVariant<T extends JsonValue>(id: VariantId, options: CreateVariantOptions<T>): Variant<T>;
    /**
     * Create a boolean variant.
     */
    createBooleanVariant(id: VariantId, value: boolean, options?: Omit<CreateVariantOptions<boolean>, 'value'>): Variant<boolean>;
    /**
     * Create a string variant.
     */
    createStringVariant(id: VariantId, value: string, options?: Omit<CreateVariantOptions<string>, 'value'>): Variant<string>;
    /**
     * Create a number variant.
     */
    createNumberVariant(id: VariantId, value: number, options?: Omit<CreateVariantOptions<number>, 'value'>): Variant<number>;
    /**
     * Create a JSON variant.
     */
    createJsonVariant<T extends JsonValue>(id: VariantId, value: T, options?: Omit<CreateVariantOptions<T>, 'value'>): Variant<T>;
    /**
     * Infer the value type from a value.
     */
    inferValueType(value: JsonValue): VariantValueType;
    /**
     * Validate a variant value against its declared type.
     */
    validateVariant(variant: Variant): boolean;
    /**
     * Coerce a value to the expected type.
     */
    coerceValue<T extends JsonValue>(value: unknown, targetType: VariantValueType): T | null;
    /**
     * Select a variant based on a bucket value and allocations.
     */
    selectVariant<T extends JsonValue>(variants: readonly Variant<T>[], bucket: number, allocations?: readonly VariantAllocation[]): Variant<T> | null;
    /**
     * Get the control variant from a list.
     */
    getControlVariant<T extends JsonValue>(variants: readonly Variant<T>[]): Variant<T> | null;
    /**
     * Get all treatment (non-control) variants.
     */
    getTreatmentVariants<T extends JsonValue>(variants: readonly Variant<T>[]): Variant<T>[];
    /**
     * Create equal allocations for variants.
     */
    createEqualAllocations(variants: readonly Variant[]): VariantAllocation[];
    /**
     * Create weighted allocations with control getting most traffic.
     */
    createControlHeavyAllocations(variants: readonly Variant[], controlPercentage?: number): VariantAllocation[];
}
/**
 * Fluent builder for creating variants.
 */
export declare class VariantBuilder<T extends JsonValue = JsonValue> {
    private variant;
    /**
     * Set the variant ID.
     */
    id(id: VariantId): this;
    /**
     * Set the variant name.
     */
    name(name: string): this;
    /**
     * Set the variant description.
     */
    description(description: string): this;
    /**
     * Set the variant value.
     */
    value(value: T): this;
    /**
     * Mark as control variant.
     */
    asControl(): this;
    /**
     * Add payload data.
     */
    payload(data: Record<string, JsonValue>): this;
    /**
     * Add attachments.
     */
    attachments(...files: string[]): this;
    /**
     * Build the variant.
     */
    build(): Variant<T>;
}
/**
 * Create a new variant builder.
 */
export declare function createVariant<T extends JsonValue = JsonValue>(): VariantBuilder<T>;
/**
 * Common variant patterns.
 */
export declare const VariantSets: {
    /**
     * Simple on/off boolean variants.
     */
    boolean(): [Variant<boolean>, Variant<boolean>];
    /**
     * A/B test variants (control + treatment).
     */
    abTest<T extends JsonValue>(controlValue: T, treatmentValue: T): [Variant<T>, Variant<T>];
    /**
     * A/B/C test variants.
     */
    abcTest<T extends JsonValue>(controlValue: T, treatmentAValue: T, treatmentBValue: T): [Variant<T>, Variant<T>, Variant<T>];
    /**
     * Multi-value variants from a map.
     */
    fromMap<T extends JsonValue>(values: Record<string, T>, controlId?: string): Variant<T>[];
    /**
     * Color variants for UI experiments.
     */
    colors(colors: Record<string, string>, controlColor?: string): Variant<string>[];
    /**
     * Size variants (e.g., for button sizes).
     */
    sizes(): Variant<string>[];
};
/**
 * Calculate basic statistics for a variant.
 */
export declare function calculateVariantStats(variantId: VariantId, values: number[], conversions: number): VariantStats;
/**
 * Compare two variants using a z-test.
 */
export declare function compareVariants(control: VariantStats, treatment: VariantStats, confidenceLevel?: number): VariantComparison;
/**
 * Get the singleton variant manager instance.
 */
export declare function getVariantManager(): VariantManager;