import { MixedSet } from "../utility/MixedSet.js";
import * as Result from "../utility/result.js";
import * as Continuous from "./Continuous.js";
import { ContinuousShape } from "./Continuous.js";
import * as Discrete from "./Discrete.js";
import { DiscreteShape } from "./Discrete.js";
import * as MixedPoint from "./MixedPoint.js";
import { ConvolutionOperation, PointSet } from "./PointSet.js";
export type SerializedMixedShape = {
    discrete: Discrete.SerializedDiscreteShape;
    continuous: Continuous.SerializedContinuousShape;
};
export declare class MixedShape implements PointSet<MixedShape> {
    readonly continuous: ContinuousShape;
    readonly discrete: DiscreteShape;
    private _integralSumCache?;
    private _integralCache?;
    constructor(args: {
        continuous: ContinuousShape;
        discrete: DiscreteShape;
        integralSumCache?: number;
        integralCache?: ContinuousShape;
    });
    get integralCache(): Continuous.ContinuousShape | undefined;
    get integralSumCache(): number | undefined;
    withAdjustedIntegralSum(integralSumCache: number): MixedShape;
    minX(): number;
    maxX(): number;
    isEmpty(): boolean;
    toContinuous(): Continuous.ContinuousShape;
    toDiscrete(): Discrete.DiscreteShape;
    toMixed(): this;
    isEqual(other: MixedShape): boolean;
    truncate(leftCutoff: number | undefined, rightCutoff: number | undefined): MixedShape;
    normalize(): MixedShape;
    xToY(x: number): MixedPoint.MixedPoint;
    toDiscreteProbabilityMassFraction(): number;
    downsample(count: number): MixedShape;
    integral(): Continuous.ContinuousShape;
    integralSum(): number;
    integralXtoY(f: number): number;
    integralYtoX(f: number): number;
    support(): MixedSet;
    mapY(fn: (y: number) => number, integralSumCacheFn: ((sum: number) => number | undefined) | undefined, integralCacheFn: ((cache: ContinuousShape) => ContinuousShape | undefined) | undefined): MixedShape;
    mapYResult<E>(fn: (y: number) => Result.result<number, E>, integralSumCacheFn: undefined | ((sum: number) => number | undefined), integralCacheFn: undefined | ((cache: ContinuousShape) => ContinuousShape | undefined)): Result.result<MixedShape, E>;
    mean(): number;
    variance(): number;
    yTransform(): MixedShape;
    serialize(): SerializedMixedShape;
    static deserialize({ continuous, discrete, }: SerializedMixedShape): MixedShape;
}
export declare const combineAlgebraically: (op: ConvolutionOperation, t1: MixedShape, t2: MixedShape) => MixedShape;
export declare const combinePointwise: <E>(t1: MixedShape, t2: MixedShape, fn: (v1: number, v2: number) => Result.result<number, E>, integralSumCachesFn?: (v1: number, v2: number) => number | undefined, integralCachesFn?: (v1: ContinuousShape, v2: ContinuousShape) => ContinuousShape | undefined) => Result.result<MixedShape, E>;
export declare function buildMixedShape({ continuous, discrete, }: {
    continuous?: ContinuousShape;
    discrete?: DiscreteShape;
}): MixedShape | undefined;
//# sourceMappingURL=Mixed.d.ts.map