import type { DiceExpression } from './dice-expression';
/**
 * A discrete probability distribution over values of type `T`.
 *
 * The `values` map sends each possible outcome to its probability mass; the
 * probabilities sum to 1 (modulo small floating-point error).
 *
 * Note on map keys: JavaScript `Map` uses SameValueZero / reference equality
 * for keys. `T` should be a primitive (number, string, boolean) or an
 * intentionally stable reference; otherwise distinct objects with the same
 * shape will be treated as different outcomes.
 */
export interface Distribution<T> {
    values: Map<T, number>;
}
declare function singleton<T>(value: T): Distribution<T>;
declare function uniform<T>(values: T[]): Distribution<T>;
declare function fromMap<T>(map: Map<T, number>): Distribution<T>;
declare function fromWeights<T>(entries: Array<[T, number]>): Distribution<T>;
declare function mapDist<T, U>(d: Distribution<T>, fn: (v: T) => U): Distribution<U>;
declare function combine<A, B, C>(a: Distribution<A>, b: Distribution<B>, fn: (av: A, bv: B) => C): Distribution<C>;
declare function conditional<T>(cond: Distribution<boolean>, thenD: Distribution<T>, elseD: Distribution<T>): Distribution<T>;
declare function add(a: Distribution<number>, b: Distribution<number>): Distribution<number>;
declare function subtract(a: Distribution<number>, b: Distribution<number>): Distribution<number>;
declare function multiply(a: Distribution<number>, b: Distribution<number>): Distribution<number>;
declare function negate(d: Distribution<number>): Distribution<number>;
declare function and(a: Distribution<boolean>, b: Distribution<boolean>): Distribution<boolean>;
declare function or(a: Distribution<boolean>, b: Distribution<boolean>): Distribution<boolean>;
declare function not(d: Distribution<boolean>): Distribution<boolean>;
declare function greaterThan(a: Distribution<number>, b: Distribution<number>): Distribution<boolean>;
declare function lessThan(a: Distribution<number>, b: Distribution<number>): Distribution<boolean>;
declare function greaterOrEqual(a: Distribution<number>, b: Distribution<number>): Distribution<boolean>;
declare function lessOrEqual(a: Distribution<number>, b: Distribution<number>): Distribution<boolean>;
declare function equal<T>(a: Distribution<T>, b: Distribution<T>): Distribution<boolean>;
declare function greaterThanConst(d: Distribution<number>, k: number): Distribution<boolean>;
declare function lessThanConst(d: Distribution<number>, k: number): Distribution<boolean>;
declare function greaterOrEqualConst(d: Distribution<number>, k: number): Distribution<boolean>;
declare function lessOrEqualConst(d: Distribution<number>, k: number): Distribution<boolean>;
declare function equalConst<T>(d: Distribution<T>, k: T): Distribution<boolean>;
declare function repeat(d: Distribution<number>, n: number): Distribution<number>;
declare function probabilityOf<T>(d: Distribution<T>, predicate: (v: T) => boolean): number;
declare function mean(d: Distribution<number>): number;
declare function variance(d: Distribution<number>): number;
declare function minOf(d: Distribution<number>): number;
declare function maxOf(d: Distribution<number>): number;
declare function fromDiceExpression(expr: DiceExpression): Distribution<number>;
/**
 * Public namespace for composing discrete probability distributions.
 *
 * All combinators assume that the input distributions are independent. If you
 * need correlations between random sources, use the program language and
 * `ProgramStats.analyze`, which tracks shared sources internally.
 */
export declare const Distribution: {
    singleton: typeof singleton;
    uniform: typeof uniform;
    from: typeof fromMap;
    fromWeights: typeof fromWeights;
    map: typeof mapDist;
    combine: typeof combine;
    conditional: typeof conditional;
    add: typeof add;
    subtract: typeof subtract;
    multiply: typeof multiply;
    negate: typeof negate;
    and: typeof and;
    or: typeof or;
    not: typeof not;
    greaterThan: typeof greaterThan;
    lessThan: typeof lessThan;
    greaterOrEqual: typeof greaterOrEqual;
    lessOrEqual: typeof lessOrEqual;
    equal: typeof equal;
    greaterThanConst: typeof greaterThanConst;
    lessThanConst: typeof lessThanConst;
    greaterOrEqualConst: typeof greaterOrEqualConst;
    lessOrEqualConst: typeof lessOrEqualConst;
    equalConst: typeof equalConst;
    repeat: typeof repeat;
    probabilityOf: typeof probabilityOf;
    mean: typeof mean;
    variance: typeof variance;
    min: typeof minOf;
    max: typeof maxOf;
    fromDiceExpression: typeof fromDiceExpression;
};
export {};